diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..18a6d25 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,64 @@ +# EditorConfig is awesome: https://EditorConfig.org + +# top-most EditorConfig file +root = true + +# Default settings for all files +[*] +charset = utf-8 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true +indent_style = space +indent_size = 2 + +# Markdown files +[*.{md,markdown}] +trim_trailing_whitespace = false # Trailing whitespace is significant in Markdown + +# Python files +[*.py] +indent_size = 4 +max_line_length = 88 # Black formatter default + +# C# files +[*.cs] +indent_size = 4 +csharp_new_line_before_open_brace = all +csharp_space_between_method_declaration_parameter_list_parentheses = false +csharp_space_between_method_call_parameter_list_parentheses = false +csharp_space_after_keywords_in_control_flow_statements = true +csharp_space_between_parentheses = false + +# JavaScript/TypeScript files +[*.{js,ts,jsx,tsx}] +quote_type = single + +# JSON files +[*.json] +insert_final_newline = false + +# YAML files +[*.{yml,yaml}] +indent_size = 2 + +# Shell scripts +[*.sh] +indent_size = 2 + +# HTML, CSS, SCSS files +[*.{html,css,scss}] +indent_size = 2 + +# Java files +[*.java] +indent_size = 4 + +# Go files +[*.go] +indent_style = tab +indent_size = 4 + +# Makefiles +[Makefile] +indent_style = tab diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..3b6828a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,30 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '[BUG] ' +labels: 'bug' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Additional context** +Add any other context about the problem here. + +**Possible solution** +If you have suggestions on how to fix the issue, please describe them here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/bug_report_vi.md b/.github/ISSUE_TEMPLATE/bug_report_vi.md new file mode 100644 index 0000000..1b16943 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report_vi.md @@ -0,0 +1,30 @@ +--- +name: Báo cáo lỗi +about: Tạo một báo cáo lỗi để giúp chúng tôi cải thiện +title: '[BUG] ' +labels: 'bug' +assignees: '' + +--- + +**Mô tả lỗi** +Mô tả ngắn gọn và rõ ràng về lỗi đang gặp phải. + +**Cách để tái tạo lỗi** +Các bước để tái hiện hành vi lỗi: +1. Truy cập vào '...' +2. Nhấn vào '...' +3. Cuộn xuống tới '...' +4. Thấy lỗi + +**Hành vi mong đợi** +Mô tả rõ ràng và ngắn gọn về điều bạn mong đợi sẽ xảy ra. + +**Ảnh chụp màn hình** +Nếu có, hãy thêm ảnh chụp màn hình để minh họa lỗi. + +**Ngữ cảnh bổ sung** +Thêm bất kỳ thông tin bổ sung nào về sự cố ở đây (thiết bị, trình duyệt, môi trường...). + +**Giải pháp khả thi** +Nếu bạn có gợi ý về cách khắc phục lỗi, vui lòng mô tả tại đây. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..59b656f --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,23 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '[FEATURE] ' +labels: 'enhancement' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. + +**Target topics/areas** +Which topics or sections of the repository would be affected by this feature? \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature_request_vi.md b/.github/ISSUE_TEMPLATE/feature_request_vi.md new file mode 100644 index 0000000..003b8c0 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request_vi.md @@ -0,0 +1,23 @@ +--- +name: Yêu cầu tính năng +about: Đề xuất một ý tưởng hoặc tính năng cho dự án +title: '[FEATURE] ' +labels: 'enhancement' +assignees: '' + +--- + +**Yêu cầu tính năng này có liên quan đến vấn đề nào không? Hãy mô tả.** +Mô tả rõ ràng và ngắn gọn về vấn đề. Ví dụ: Tôi thường cảm thấy khó chịu khi [...] + +**Mô tả giải pháp bạn muốn có** +Mô tả rõ ràng và ngắn gọn về điều bạn muốn xảy ra. + +**Mô tả các giải pháp thay thế bạn đã xem xét** +Mô tả rõ ràng và ngắn gọn về bất kỳ giải pháp thay thế hoặc tính năng khác mà bạn đã cân nhắc. + +**Ngữ cảnh bổ sung** +Thêm bất kỳ thông tin, bối cảnh hoặc ảnh chụp màn hình nào liên quan đến yêu cầu tính năng ở đây. + +**Các chủ đề/khu vực bị ảnh hưởng** +Những chủ đề hoặc phần nào trong repository sẽ bị ảnh hưởng bởi tính năng này? diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..75e1465 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,29 @@ +name: Markdown CI + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + check-links: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - name: Setup Node.js + uses: actions/setup-node@v3 + with: + node-version: '16' + + - name: Install dependencies + run: npm install -g markdown-link-check + + - name: Check links + run: ./tools/check_links.sh + + - name: Generate TOC + run: | + python3 ./tools/generate_summary.py + git diff --exit-code SUMMARY.md || (echo "SUMMARY.md is out of date. Please run ./tools/generate_summary.py and commit the changes" && exit 1) \ No newline at end of file diff --git a/.gitignore b/.gitignore index 69d6106..df28da4 100644 --- a/.gitignore +++ b/.gitignore @@ -3,11 +3,34 @@ node_modules/ # Python __pycache__/ -*.pyc -*.pyo -*.pyd -.env -.venv/ +*.py[cod] +*$py.class +*.so +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# C# +bin/ +obj/ +*.user +*.suo +*.userprefs +*.sln.docstates +.vs/ # VSCode settings .vscode/ @@ -42,6 +65,8 @@ coverage.xml # dotenv environment files .env.local .env.* +.env +!.env.example # Ignore generated files and backups *.orig diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 623f533..13e1ccd 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,6 +1,6 @@ # Contributing to Tech Notes Hub -First of all, thank you for taking the time to contribute! 🎉 +First of all, thank you for taking the time to contribute! 🎉 Your contributions help make this project more valuable for the developer community. ## 🚀 Ways to Contribute @@ -74,6 +74,7 @@ Write clear, meaningful, and understandable commit messages. Suggested structure - `feature: add notes on HTTP Status Codes` - `fix: correct typos in design-patterns.md` - `update: improve binary search examples` +- `refactor: reorganize folder structure` - `remove: delete duplicate notes in aws folder` - `docs: add instructions for creating pull requests` @@ -81,7 +82,7 @@ Write clear, meaningful, and understandable commit messages. Suggested structure - You can only write in **English** - **Avoid vague commits** like: `update 1`, `fix bug`, `test` -- If related to an issue, add the number at the end: +- If related to an issue, add the number at the end: 👉 `fix: typo in aws-note #12` ### 5. Commit & Push @@ -111,9 +112,9 @@ Before submitting, ensure: ## 📁 File & Folder Naming Conventions -* Use lowercase and hyphens for file and folder names: `graph-traversal.md` -* For translations, add language suffix: `graph-traversal_vi.md` -* Notes should be grouped by topic folders (e.g., `algorithms/`, `aws/`, `design-patterns/`) +* Use lowercase and hyphens for file and folder names: `graph_traversal.md` (except for code files like C# using PascalCase such as `GraphTraversal.cs`, or Java using CamelCase like `GraphTraversal.java`) +* For translations, add language suffix: `graph_traversal_vi.md` +* Notes should be grouped by docs folders (e.g., `docs/algorithms/`, `docs/aws/`, `docs/design-patterns/`) ## 🤝 Code of Conduct diff --git a/CONTRIBUTING_vi.md b/CONTRIBUTING_vi.md index cb03727..11991dd 100644 --- a/CONTRIBUTING_vi.md +++ b/CONTRIBUTING_vi.md @@ -1,6 +1,6 @@ # Đóng góp vào Tech Notes Hub -Trước hết, xin chân thành cảm ơn bạn đã dành thời gian đóng góp! 🎉 +Trước hết, xin chân thành cảm ơn bạn đã dành thời gian đóng góp! 🎉 Sự đóng góp của bạn giúp dự án này trở nên hữu ích hơn cho cộng đồng lập trình viên. ## 🚀 Cách bạn có thể đóng góp @@ -74,6 +74,7 @@ Viết commit rõ ràng, có ý nghĩa và dễ hiểu. Cấu trúc đề xuất - `feature: add notes on HTTP Status Codes` - `fix: correct typos in design-patterns.md` - `update: improve binary search examples` +- `refactor: reorganize folder structure` - `remove: delete duplicate notes in aws folder` - `docs: add instructions for creating pull requests` @@ -81,7 +82,7 @@ Viết commit rõ ràng, có ý nghĩa và dễ hiểu. Cấu trúc đề xuất - Bạn chỉ có thể viết bằng **tiếng Anh** - **Tránh commit mơ hồ** như: `update 1`, `fix bug`, `test` -- Nếu liên quan issue, thêm số vào cuối: +- Nếu liên quan issue, thêm số vào cuối: 👉 `fix: typo in aws-note #12` @@ -112,9 +113,9 @@ Trước khi gửi, hãy đảm bảo: ## 📁 Quy tắc đặt tên file & thư mục -* Tên file và thư mục dùng chữ thường và dấu gạch ngang: `graph-traversal.md` -* Nếu là bản dịch, thêm hậu tố ngôn ngữ: `graph-traversal_vi.md` -* Ghi chú nên được nhóm theo thư mục chuyên đề (ví dụ: `algorithms/`, `aws/`, `design-patterns/`) +* Tên file và thư mục dùng chữ thường và dấu gạch ngang: `graph_traversal.md` (trừ code như C# sử dụng PascalCase như `GraphTraversal.cs`, hoặc Java sử dụng CamelCase như `GraphTraversal.java`) +* Nếu là bản dịch, thêm hậu tố ngôn ngữ: `graph_traversal_vi.md` +* Ghi chú nên được nhóm theo thư mục trong docs (ví dụ: `docs/algorithms/`, `docs/aws/`, `docs/design-patterns/`) ## 🤝 Quy tắc ứng xử diff --git a/PULL_REQUEST_RULES.md b/PULL_REQUEST_RULES.md index 3a3793d..b25ef90 100644 --- a/PULL_REQUEST_RULES.md +++ b/PULL_REQUEST_RULES.md @@ -6,6 +6,36 @@ Please read carefully before submitting a PR. --- +## 📝 Pull Request Template + +When submitting a pull request, please include: + +### Description +A clear description of the changes you have made. + +### Related Issue +Link to any related issues: `Fixes #(issue number)` + +### Type of Change +Select the appropriate options: +- [ ] New content (notes, snippets) +- [ ] Content improvement (updates, fixes, expansion) +- [ ] Documentation update +- [ ] Bug fix (non-breaking change which fixes an issue) +- [ ] Infrastructure/tooling (CI, scripts, etc.) +- [ ] Translation (i18n) - specify language: ______ +- [ ] Other (please describe) + +### Checklist +- [ ] My content follows the style guidelines of this project +- [ ] I have performed a self-review of my own content/code +- [ ] I have included references/links where appropriate +- [ ] My changes generate no new warnings or errors +- [ ] I have checked that all links are valid +- [ ] For translations: I've followed the i18n folder structure (i18n/[language_code]/...) + +--- + ## ✅ Allowed in Pull Requests - **New content** such as: @@ -22,8 +52,9 @@ Please read carefully before submitting a PR. - Typo and grammar fixes - Markdown formatting or link corrections - **New language versions**: - - Translations with `_vi.md`, `_fr.md`, etc. suffix + - Translations in the `i18n/[language_code]/` folder structure (e.g., `i18n/vi/`, `i18n/fr/`) - Must match the structure and logic of the original file + - Should be referenced in the SUMMARY.md under appropriate language section ## ❌ Not Allowed in Pull Requests @@ -34,19 +65,21 @@ Please read carefully before submitting a PR. - ❌ Personal promotion, affiliate links, or ads - ❌ Files with broken structure, invalid markdown, or irrelevant naming - ❌ Notes that contain **plagiarized content** (copying from copyrighted materials) +- ❌ Translations not following the proper i18n folder structure ## 🔖 Style & Structure Reminders - Use clear, **conversational but concise** explanations - Use correct heading hierarchy (`#`, `##`, `###`, etc.) - Name files using lowercase and hyphens: `binary-search.md` -- For translated files, append language suffix: `binary-search_vi.md` - Place content in the appropriate folder (`algorithms/`, `design-patterns/`, etc.) +- For translations, use the `i18n/[language_code]/` structure, mirroring the main docs structure +- Update SUMMARY.md to include new content or translations ## 📢 Final Note -We appreciate your contribution and effort! -All pull requests will be reviewed by maintainers before merging. +We appreciate your contribution and effort! +All pull requests will be reviewed by maintainers before merging. Feel free to open a discussion issue if you're unsure whether something fits. -Let’s build a high-quality, developer-friendly knowledge base together. 🚀 +Let's build a high-quality, developer-friendly knowledge base together. 🚀 diff --git a/PULL_REQUEST_RULES_vi.md b/PULL_REQUEST_RULES_vi.md index 58b9022..a8d0fec 100644 --- a/PULL_REQUEST_RULES_vi.md +++ b/PULL_REQUEST_RULES_vi.md @@ -6,6 +6,36 @@ Vui lòng đọc kỹ trước khi gửi PR. --- +## 📝 Mẫu Pull Request + +Khi gửi pull request, vui lòng bao gồm: + +### Mô tả +Mô tả rõ ràng về các thay đổi bạn đã thực hiện. + +### Vấn đề liên quan +Liên kết đến các vấn đề liên quan: `Fixes #(số issue)` + +### Loại thay đổi +Chọn các tùy chọn thích hợp: +- [ ] Nội dung mới (ghi chú, đoạn mã) +- [ ] Cải thiện nội dung (cập nhật, sửa lỗi, mở rộng) +- [ ] Cập nhật tài liệu +- [ ] Sửa lỗi (thay đổi không gây ảnh hưởng) +- [ ] Cơ sở hạ tầng/công cụ (CI, scripts, v.v.) +- [ ] Bản dịch (i18n) - chỉ rõ ngôn ngữ: ______ +- [ ] Khác (vui lòng mô tả) + +### Danh sách kiểm tra +- [ ] Nội dung của tôi tuân theo hướng dẫn về phong cách của dự án +- [ ] Tôi đã tự đánh giá nội dung/mã của mình +- [ ] Tôi đã bao gồm tài liệu tham khảo/liên kết khi thích hợp +- [ ] Các thay đổi của tôi không tạo ra cảnh báo hoặc lỗi mới +- [ ] Tôi đã kiểm tra rằng tất cả các liên kết đều hợp lệ +- [ ] Đối với bản dịch: Tôi đã tuân theo cấu trúc thư mục i18n (i18n/[language_code]/...) + +--- + ## ✅ Được phép trong Pull Request - **Thêm nội dung mới** như: @@ -22,8 +52,9 @@ Vui lòng đọc kỹ trước khi gửi PR. - Sửa lỗi chính tả, ngữ pháp - Cập nhật liên kết hoặc định dạng Markdown - **Bản dịch ghi chú**: - - Dùng hậu tố `_vi.md`, `_ja.md`, v.v. + - Sử dụng cấu trúc thư mục `i18n/[mã_ngôn_ngữ]/` (ví dụ: `i18n/vi/`, `i18n/fr/`) - Nội dung bám sát logic file gốc + - Cập nhật trong SUMMARY.md dưới phần ngôn ngữ tương ứng ## ❌ Không được phép trong Pull Request @@ -34,19 +65,21 @@ Vui lòng đọc kỹ trước khi gửi PR. - ❌ Chèn liên kết quảng cáo, giới thiệu cá nhân, affiliate link - ❌ File đặt tên sai quy tắc, không dùng định dạng Markdown hợp lệ - ❌ Nội dung **sao chép có bản quyền** từ nguồn khác +- ❌ Bản dịch không tuân thủ cấu trúc thư mục i18n đúng quy định ## 🔖 Lưu ý về cấu trúc & định dạng - Trình bày **ngắn gọn, dễ hiểu, gần gũi** - Sử dụng đúng cấp độ tiêu đề: `#`, `##`, `###`,... - Đặt tên file bằng chữ thường, dùng dấu gạch ngang: `binary-search.md` -- File dịch có hậu tố ngôn ngữ: `binary-search_vi.md` - Đặt đúng thư mục chuyên đề (`algorithms/`, `design-patterns/`, `aws/`,...) +- Đối với bản dịch, sử dụng cấu trúc `i18n/[mã_ngôn_ngữ]/`, phản ánh cấu trúc thư mục chính +- Cập nhật SUMMARY.md để bao gồm nội dung mới hoặc bản dịch ## 📢 Lưu ý cuối -Cảm ơn bạn đã đóng góp cho dự án! -Tất cả pull request sẽ được review kỹ trước khi merge. +Cảm ơn bạn đã đóng góp cho dự án! +Tất cả pull request sẽ được review kỹ trước khi merge. Nếu chưa chắc nội dung có phù hợp không, bạn có thể mở một issue để trao đổi trước. Cùng nhau xây dựng một kho kiến thức chất lượng cho lập trình viên! 🚀 diff --git a/README.md b/README.md index c555839..3a87c67 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,8 @@ It's designed to be your go-to resource whether you're preparing for interviews, Simply browse the folders or use GitHub's search feature to find the topic or pattern you need. Each note is designed to be self-contained with theory and practical code. +**For a complete table of contents with all available notes and resources, check out the [SUMMARY.md](SUMMARY.md) file.** + ## 🤝 Contribution Contributions are highly welcome! If you want to: @@ -67,6 +69,10 @@ Before submitting a pull request, make sure to check the [Pull Request Rules](PU This project is licensed under the MIT License. See the [LICENSE](LICENSE.txt) file for details. +## 📝 Changelog + +For a detailed list of all notable changes to this project, please see the [changelog](changelog.md) file. + ## 🙌 Acknowledgements Thanks to all contributors and the open source community for making this knowledge base better every day. diff --git a/README_vi.md b/README_vi.md index 3950470..1ff2b93 100644 --- a/README_vi.md +++ b/README_vi.md @@ -49,9 +49,11 @@ Dự án được thiết kế để trở thành tài nguyên tham khảo hàng ## 📖 Cách sử dụng -Bạn có thể duyệt các thư mục hoặc dùng tính năng tìm kiếm của GitHub để tra cứu chủ đề hoặc mẫu thiết kế bạn cần. +Bạn có thể duyệt các thư mục hoặc dùng tính năng tìm kiếm của GitHub để tra cứu chủ đề hoặc mẫu thiết kế bạn cần. Mỗi ghi chú đều độc lập, bao gồm lý thuyết và mã ví dụ thực tế. +**Để xem danh mục đầy đủ với tất cả các ghi chú và tài nguyên có sẵn, hãy xem file [SUMMARY.md](SUMMARY.md).** + ## 🤝 Đóng góp Mọi đóng góp đều rất hoan nghênh! Nếu bạn muốn: @@ -68,6 +70,10 @@ Trước khi gửi pull request, vui lòng đọc kỹ [Quy định nội dung P Dự án này được phát hành theo giấy phép MIT. Xem chi tiết trong file [LICENSE](LICENSE.txt). +## 📝 Changelog + +Để biết danh sách chi tiết về tất cả những thay đổi đáng chú ý trong dự án này, vui lòng xem tệp [changelog](changelog_vi.md). + ## 🙌 Lời cảm ơn Cảm ơn tất cả các contributors và cộng đồng mã nguồn mở đã cùng nhau làm phong phú thêm kho kiến thức này mỗi ngày. diff --git a/SUMMARY.md b/SUMMARY.md new file mode 100644 index 0000000..3497c69 --- /dev/null +++ b/SUMMARY.md @@ -0,0 +1,34 @@ +# Tech Notes Hub + +## Table of Contents + +### Algorithms + +- [Graph Traversal Algorithms](docs/algorithms/graph-traversal.md) + +### Databases + +- [Relational Databases](docs/databases/relational.md) + +### Design Patterns + +- [Factory Design Pattern](docs/design-patterns/factory.md) +- [Observer Design Pattern](docs/design-patterns/observer.md) +- [Singleton Design Pattern](docs/design-patterns/singleton.md) + +### Devops + +- [Continuous Integration and Continuous Deployment (CI/CD)](docs/devops/ci-cd.md) + +### Linux + +- [Bash Scripting](docs/linux/bash-scripting.md) + +### System Design + +- [Microservices Architecture](docs/system-design/microservices.md) + +### Testing + +- [Unit Testing](docs/testing/unit-testing.md) + diff --git a/assets/diagrams/init.txt b/assets/diagrams/init.txt new file mode 100644 index 0000000..e69de29 diff --git a/assets/init.txt b/assets/init.txt new file mode 100644 index 0000000..e69de29 diff --git a/changelog.md b/changelog.md new file mode 100644 index 0000000..e12ea66 --- /dev/null +++ b/changelog.md @@ -0,0 +1,31 @@ +# Big changelog + +All notable changes to the Tech Notes Hub project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +### Added +- Security enhancement: Moved database credentials to environment variables +- Added database code examples for Python and C# +- Added design pattern implementations (Observer, Factory, Singleton) +- Created comprehensive documentation in English and Vietnamese + +### Changed +- Restructured repository to match documentation and code examples +- Updated SQL examples to use parameterized queries for better security +- Improved code organization in snippets directory + +### Security +- Removed hardcoded database credentials +- Added .env.example file with placeholder values +- Updated .gitignore to prevent committing sensitive information + +## [1.0.0] - 2025-06-04 + +### Added +- Initial repository structure +- Basic documentation framework +- Core code examples for algorithms and data structures diff --git a/changelog_vi.md b/changelog_vi.md new file mode 100644 index 0000000..a4bc9b1 --- /dev/null +++ b/changelog_vi.md @@ -0,0 +1,31 @@ +# Nhật ký thay đổi lớn + +Tất cả những thay đổi đáng chú ý đối với dự án Tech Notes Hub sẽ được ghi lại trong tệp này. + +Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +và dự án này tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Chưa phát hành] + +### Đã thêm +- Tăng cường bảo mật: Chuyển thông tin đăng nhập cơ sở dữ liệu vào biến môi trường +- Thêm các ví dụ mã nguồn cơ sở dữ liệu cho Python và C# +- Thêm các triển khai mẫu thiết kế (Observer, Factory, Singleton) +- Tạo tài liệu toàn diện bằng tiếng Anh và tiếng Việt + +### Đã thay đổi +- Cơ cấu lại kho lưu trữ để phù hợp với tài liệu và các ví dụ mã nguồn +- Cập nhật các ví dụ SQL để sử dụng truy vấn có tham số để bảo mật tốt hơn +- Cải thiện tổ chức mã trong thư mục snippets + +### Bảo mật +- Loại bỏ thông tin đăng nhập cơ sở dữ liệu được mã hóa cứng +- Thêm tệp .env.example với các giá trị giữ chỗ +- Cập nhật .gitignore để ngăn chặn việc commit thông tin nhạy cảm + +## [1.0.0] - 2025-06-04 + +### Đã thêm +- Cấu trúc kho lưu trữ ban đầu +- Khung tài liệu cơ bản +- Các ví dụ mã nguồn cốt lõi cho thuật toán và cấu trúc dữ liệu diff --git a/docs/_index.md b/docs/_index.md new file mode 100644 index 0000000..dac2e6e --- /dev/null +++ b/docs/_index.md @@ -0,0 +1,53 @@ +# Tech Notes Hub + +Welcome to the Tech Notes Hub! This repository is a comprehensive collection of technical notes, code snippets, and examples covering various topics in software development, system design, and computer science. + +## Purpose + +Tech Notes Hub aims to: + +- Provide clear, concise explanations of important technical concepts +- Offer practical code examples in multiple programming languages +- Serve as a reference for developers at all skill levels +- Create a collaborative knowledge base for the tech community + +## Repository Structure + +The repository is organized into the following main sections: + +### Algorithms +Implementations and explanations of common algorithms, including search, sort, graph traversal, and more. + +### Databases +Notes on database systems, query optimization, data modeling, and best practices for both SQL and NoSQL databases. + +### Design Patterns +Detailed explanations and implementations of software design patterns across multiple programming languages. + +### DevOps +Information about continuous integration, deployment, containerization, and infrastructure management. + +### Linux +Guides for Linux system administration, shell scripting, and command-line tools. + +### System Design +Approaches to designing scalable, reliable, and maintainable software systems. + +### Testing +Best practices for unit testing, integration testing, and test-driven development. + +## How to Use This Repository + +Each section contains markdown files with explanations and code snippets. You can: + +1. Browse the sections to find topics of interest +2. Use the code examples as reference for your own projects +3. Contribute by adding new content or improving existing documentation + +## Contributing + +We welcome contributions from the community! Please see our [CONTRIBUTING.md](../CONTRIBUTING.md) file for guidelines on how to contribute. + +## License + +This project is licensed under the MIT License - see the [LICENSE.txt](../LICENSE.txt) file for details. diff --git a/docs/algorithms/graph-traversal.md b/docs/algorithms/graph-traversal.md new file mode 100644 index 0000000..b16b9a2 --- /dev/null +++ b/docs/algorithms/graph-traversal.md @@ -0,0 +1,148 @@ +# Graph Traversal Algorithms + +Graph traversal algorithms are fundamental techniques used to visit every vertex in a graph. They serve as building blocks for many more complex graph algorithms. + +## Table of Contents + +- [Breadth-First Search (BFS)](#breadth-first-search-bfs) +- [Depth-First Search (DFS)](#depth-first-search-dfs) +- [Comparison of BFS and DFS](#comparison-of-bfs-and-dfs) +- [Applications](#applications) +- [Time and Space Complexity](#time-and-space-complexity) + +## Breadth-First Search (BFS) + +Breadth-First Search is a graph traversal algorithm that explores all vertices at the current depth level before moving to vertices at the next depth level. + +### How BFS Works + +1. Start at a source vertex and mark it as visited +2. Visit all its unvisited neighbors and mark them as visited +3. For each of those neighbors, visit all of their unvisited neighbors +4. Repeat until all vertices have been visited + +### Implementation + +```python +from collections import deque + +def bfs(graph, start): + visited = set([start]) + queue = deque([start]) + result = [] + + while queue: + vertex = queue.popleft() + result.append(vertex) + + for neighbor in graph[vertex]: + if neighbor not in visited: + visited.add(neighbor) + queue.append(neighbor) + + return result + +# Example usage +graph = { + 'A': ['B', 'C'], + 'B': ['A', 'D', 'E'], + 'C': ['A', 'F'], + 'D': ['B'], + 'E': ['B', 'F'], + 'F': ['C', 'E'] +} + +print(bfs(graph, 'A')) # Output: ['A', 'B', 'C', 'D', 'E', 'F'] +``` + +## Depth-First Search (DFS) + +Depth-First Search is a graph traversal algorithm that explores as far as possible along each branch before backtracking. + +### How DFS Works + +1. Start at a source vertex and mark it as visited +2. Recursively visit one of its unvisited neighbors +3. Continue this process, going deeper into the graph +4. When you reach a vertex with no unvisited neighbors, backtrack + +### Implementation + +```python +def dfs_recursive(graph, vertex, visited=None, result=None): + if visited is None: + visited = set() + if result is None: + result = [] + + visited.add(vertex) + result.append(vertex) + + for neighbor in graph[vertex]: + if neighbor not in visited: + dfs_recursive(graph, neighbor, visited, result) + + return result + +# Iterative implementation using a stack +def dfs_iterative(graph, start): + visited = set() + stack = [start] + result = [] + + while stack: + vertex = stack.pop() + if vertex not in visited: + visited.add(vertex) + result.append(vertex) + + # Add neighbors in reverse order to simulate recursive DFS + for neighbor in reversed(graph[vertex]): + if neighbor not in visited: + stack.append(neighbor) + + return result + +# Example usage (same graph as BFS example) +print(dfs_recursive(graph, 'A')) # Output might be: ['A', 'B', 'D', 'E', 'F', 'C'] +print(dfs_iterative(graph, 'A')) # Similar output, might vary depending on neighbor order +``` + +## Comparison of BFS and DFS + +| Aspect | BFS | DFS | +|--------|-----|-----| +| Data Structure | Queue | Stack (or recursion) | +| Space Complexity | O(b^d) where b is branching factor and d is distance from source | O(h) where h is the height of the tree | +| Completeness | Complete (finds all nodes at a given depth before moving deeper) | Not complete for infinite graphs | +| Optimality | Optimal for unweighted graphs | Not optimal in general | +| Use Case | Shortest path in unweighted graphs, level order traversal | Topological sorting, cycle detection, path finding | + +## Applications + +- **BFS Applications**: + - Finding the shortest path in unweighted graphs + - Finding all nodes within one connected component + - Testing bipartiteness of a graph + - Web crawlers + - Social networking features (e.g., "Friends within 2 connections") + +- **DFS Applications**: + - Topological sorting + - Finding strongly connected components + - Solving puzzles with only one solution (e.g., mazes) + - Cycle detection + - Path finding in games and puzzles + +## Time and Space Complexity + +Both BFS and DFS have a time complexity of O(V + E) where V is the number of vertices and E is the number of edges. This is because in the worst case, each vertex and each edge will be explored once. + +Space complexity: +- BFS: O(V) in the worst case when all vertices are stored in the queue +- DFS: O(h) where h is the maximum depth of the recursion stack (which could be O(V) in the worst case) + +## References + +1. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press. +2. Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley Professional. \ No newline at end of file diff --git a/docs/databases/relational.md b/docs/databases/relational.md new file mode 100644 index 0000000..82132a6 --- /dev/null +++ b/docs/databases/relational.md @@ -0,0 +1,117 @@ +# Relational Databases + +Relational databases are organized collections of data that store information in tables with rows and columns. They follow the relational model proposed by Edgar F. Codd in 1970, which emphasizes relationships between data entities. + +## Core Concepts + +### Tables (Relations) + +The fundamental structure in relational databases: +- Each **table** represents an entity type (e.g., customers, products) +- Each **row** (tuple) represents an instance of that entity +- Each **column** (attribute) represents a property of that entity + +### Keys + +Keys establish relationships and ensure data integrity: + +- **Primary Key**: Uniquely identifies each record in a table +- **Foreign Key**: References a primary key in another table, establishing relationships +- **Composite Key**: Combines multiple columns to form a unique identifier +- **Candidate Key**: A column or set of columns that could serve as a primary key + +### Schema + +A schema defines the structure of the database: +- Table definitions +- Column data types and constraints +- Relationships between tables + +## SQL (Structured Query Language) + +SQL is the standard language for interacting with relational databases. + +### Basic SQL Commands + +```sql +-- Create a table +CREATE TABLE customers ( + customer_id INT PRIMARY KEY, + name VARCHAR(100), + email VARCHAR(100), + signup_date DATE +); + +-- Insert data +INSERT INTO customers (customer_id, name, email, signup_date) +VALUES (1, 'John Smith', 'john@example.com', '2023-01-15'); + +-- Query data +SELECT * FROM customers WHERE signup_date > '2023-01-01'; + +-- Update data +UPDATE customers SET email = 'john.smith@example.com' WHERE customer_id = 1; + +-- Delete data +DELETE FROM customers WHERE customer_id = 1; +``` + +## Normalization + +Normalization is the process of organizing data to reduce redundancy and improve data integrity: + +- **First Normal Form (1NF)**: Eliminate duplicate columns and create separate tables for related data +- **Second Normal Form (2NF)**: Meet 1NF requirements and remove partial dependencies +- **Third Normal Form (3NF)**: Meet 2NF requirements and remove transitive dependencies + +## ACID Properties + +Transactions in relational databases follow ACID properties: + +- **Atomicity**: Transactions are all-or-nothing operations +- **Consistency**: Transactions bring the database from one valid state to another +- **Isolation**: Concurrent transactions don't interfere with each other +- **Durability**: Completed transactions persist even in case of system failure + +## Popular Relational Database Systems + +- **MySQL**: Open-source, widely used for web applications +- **PostgreSQL**: Advanced open-source database with extensive features +- **Oracle Database**: Enterprise-level commercial database +- **Microsoft SQL Server**: Microsoft's commercial database solution +- **SQLite**: Lightweight, serverless database engine + +## Indexes + +Indexes speed up data retrieval operations: +- Similar to a book index +- Improves query performance but adds overhead for write operations +- Types include B-tree, hash, and bitmap indexes + +## Joins + +Joins combine records from two or more tables: +- **INNER JOIN**: Returns records with matching values in both tables +- **LEFT JOIN**: Returns all records from the left table and matching records from the right +- **RIGHT JOIN**: Returns all records from the right table and matching records from the left +- **FULL JOIN**: Returns all records when there's a match in either table + +```sql +SELECT customers.name, orders.order_date +FROM customers +INNER JOIN orders ON customers.customer_id = orders.customer_id; +``` + +## When to Use Relational Databases + +Relational databases are ideal for: +- Structured data with clear relationships +- Applications requiring complex queries and transactions +- Systems where data integrity is critical +- Scenarios where consistency is more important than speed + +## References + +- Codd, E.F. (1970). "A Relational Model of Data for Large Shared Data Banks" +- Date, C.J. "An Introduction to Database Systems" +- Garcia-Molina, H., Ullman, J.D., & Widom, J. "Database Systems: The Complete Book" \ No newline at end of file diff --git a/docs/design-patterns/factory.md b/docs/design-patterns/factory.md new file mode 100644 index 0000000..2ab9d1b --- /dev/null +++ b/docs/design-patterns/factory.md @@ -0,0 +1,476 @@ +# Factory Design Pattern + +The Factory pattern is a creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. + +## Intent + +- Create objects without exposing the instantiation logic to the client +- Refer to newly created objects using a common interface +- Decouple the implementation of an object from its use + +## Problem + +When should you use the Factory pattern? + +- When a class cannot anticipate the type of objects it needs to create +- When a class wants its subclasses to specify the objects it creates +- When you want to localize the knowledge of which class gets created + +## Types of Factory Patterns + +There are several variations of the Factory pattern: + +1. **Simple Factory** - Not a formal pattern, but a simple way to separate object creation +2. **Factory Method** - Defines an interface for creating objects, but lets subclasses decide which classes to instantiate +3. **Abstract Factory** - Provides an interface for creating families of related or dependent objects + +## Structure + +### Factory Method Pattern + +![Factory Method Pattern Structure](https://refactoring.guru/images/patterns/diagrams/factory-method/structure.png) + +### Abstract Factory Pattern + +![Abstract Factory Pattern Structure](https://refactoring.guru/images/patterns/diagrams/abstract-factory/structure.png) + +## Implementation + +### Simple Factory Example + +```java +// Product interface +interface Product { + void operation(); +} + +// Concrete products +class ConcreteProductA implements Product { + @Override + public void operation() { + System.out.println("ConcreteProductA operation"); + } +} + +class ConcreteProductB implements Product { + @Override + public void operation() { + System.out.println("ConcreteProductB operation"); + } +} + +// Simple factory +class SimpleFactory { + public Product createProduct(String type) { + if (type.equals("A")) { + return new ConcreteProductA(); + } else if (type.equals("B")) { + return new ConcreteProductB(); + } + throw new IllegalArgumentException("Invalid product type: " + type); + } +} + +// Client code +class Client { + public static void main(String[] args) { + SimpleFactory factory = new SimpleFactory(); + + Product productA = factory.createProduct("A"); + productA.operation(); + + Product productB = factory.createProduct("B"); + productB.operation(); + } +} +``` + +### Factory Method Example + +```java +// Product interface +interface Product { + void operation(); +} + +// Concrete products +class ConcreteProductA implements Product { + @Override + public void operation() { + System.out.println("ConcreteProductA operation"); + } +} + +class ConcreteProductB implements Product { + @Override + public void operation() { + System.out.println("ConcreteProductB operation"); + } +} + +// Creator abstract class with factory method +abstract class Creator { + public abstract Product createProduct(); + + // The creator can also include some business logic + public void someOperation() { + // Call the factory method to create a Product object + Product product = createProduct(); + // Use the product + product.operation(); + } +} + +// Concrete creators override factory method +class ConcreteCreatorA extends Creator { + @Override + public Product createProduct() { + return new ConcreteProductA(); + } +} + +class ConcreteCreatorB extends Creator { + @Override + public Product createProduct() { + return new ConcreteProductB(); + } +} + +// Client code +class Client { + public static void main(String[] args) { + Creator creatorA = new ConcreteCreatorA(); + creatorA.someOperation(); + + Creator creatorB = new ConcreteCreatorB(); + creatorB.someOperation(); + } +} +``` + +### Abstract Factory Example + +```java +// Abstract products +interface ProductA { + void operationA(); +} + +interface ProductB { + void operationB(); +} + +// Concrete products for family 1 +class ConcreteProductA1 implements ProductA { + @Override + public void operationA() { + System.out.println("Product A1 operation"); + } +} + +class ConcreteProductB1 implements ProductB { + @Override + public void operationB() { + System.out.println("Product B1 operation"); + } +} + +// Concrete products for family 2 +class ConcreteProductA2 implements ProductA { + @Override + public void operationA() { + System.out.println("Product A2 operation"); + } +} + +class ConcreteProductB2 implements ProductB { + @Override + public void operationB() { + System.out.println("Product B2 operation"); + } +} + +// Abstract factory interface +interface AbstractFactory { + ProductA createProductA(); + ProductB createProductB(); +} + +// Concrete factories +class ConcreteFactory1 implements AbstractFactory { + @Override + public ProductA createProductA() { + return new ConcreteProductA1(); + } + + @Override + public ProductB createProductB() { + return new ConcreteProductB1(); + } +} + +class ConcreteFactory2 implements AbstractFactory { + @Override + public ProductA createProductA() { + return new ConcreteProductA2(); + } + + @Override + public ProductB createProductB() { + return new ConcreteProductB2(); + } +} + +// Client code +class Client { + private ProductA productA; + private ProductB productB; + + public Client(AbstractFactory factory) { + productA = factory.createProductA(); + productB = factory.createProductB(); + } + + public void executeOperations() { + productA.operationA(); + productB.operationB(); + } +} +``` + +## Examples in Different Languages + +### JavaScript + +```javascript +// Factory Method in JavaScript + +// Product interface is implicit in JavaScript +class Dog { + speak() { + return "Woof!"; + } +} + +class Cat { + speak() { + return "Meow!"; + } +} + +// Creator +class AnimalFactory { + // Factory method + createAnimal(type) { + switch(type) { + case 'dog': + return new Dog(); + case 'cat': + return new Cat(); + default: + throw new Error(`Animal type ${type} is not supported.`); + } + } +} + +// Usage +const factory = new AnimalFactory(); +const dog = factory.createAnimal('dog'); +const cat = factory.createAnimal('cat'); + +console.log(dog.speak()); // Outputs: Woof! +console.log(cat.speak()); // Outputs: Meow! +``` + +### Python + +```python +from abc import ABC, abstractmethod + +# Abstract Product +class Button(ABC): + @abstractmethod + def render(self): + pass + + @abstractmethod + def on_click(self): + pass + +# Concrete Products +class HTMLButton(Button): + def render(self): + return "" + + def on_click(self): + return "HTML Button clicked!" + +class WindowsButton(Button): + def render(self): + return "Windows Button" + + def on_click(self): + return "Windows Button clicked!" + +# Abstract Creator +class Dialog(ABC): + @abstractmethod + def create_button(self) -> Button: + pass + + def render(self): + # Call the factory method to create a button object + button = self.create_button() + # Now use the product + return f"Dialog rendering with {button.render()}" + +# Concrete Creators +class HTMLDialog(Dialog): + def create_button(self) -> Button: + return HTMLButton() + +class WindowsDialog(Dialog): + def create_button(self) -> Button: + return WindowsButton() + +# Client code +def client_code(dialog: Dialog): + print(dialog.render()) + +# Based on environment, we select the appropriate dialog +import sys +if sys.platform.startswith('win'): + dialog = WindowsDialog() +else: + dialog = HTMLDialog() + +client_code(dialog) +``` + +### C# + +```csharp +using System; + +// Abstract Product +public interface IVehicle +{ + void Drive(); +} + +// Concrete Products +public class Car : IVehicle +{ + public void Drive() + { + Console.WriteLine("Driving a car..."); + } +} + +public class Motorcycle : IVehicle +{ + public void Drive() + { + Console.WriteLine("Driving a motorcycle..."); + } +} + +// Abstract Creator +public abstract class VehicleFactory +{ + // Factory Method + public abstract IVehicle CreateVehicle(); + + public void DeliverVehicle() + { + IVehicle vehicle = CreateVehicle(); + Console.WriteLine("Delivering the vehicle..."); + vehicle.Drive(); + } +} + +// Concrete Creators +public class CarFactory : VehicleFactory +{ + public override IVehicle CreateVehicle() + { + return new Car(); + } +} + +public class MotorcycleFactory : VehicleFactory +{ + public override IVehicle CreateVehicle() + { + return new Motorcycle(); + } +} + +// Client code +public class Program +{ + public static void Main() + { + VehicleFactory factory = GetFactory("car"); + factory.DeliverVehicle(); + + factory = GetFactory("motorcycle"); + factory.DeliverVehicle(); + } + + private static VehicleFactory GetFactory(string vehicleType) + { + switch (vehicleType.ToLower()) + { + case "car": + return new CarFactory(); + case "motorcycle": + return new MotorcycleFactory(); + default: + throw new ArgumentException($"Vehicle type {vehicleType} is not supported."); + } + } +} +``` + +## Use Cases + +- **UI Component Creation**: Creating different UI components based on user preferences or platform +- **Database Connections**: Creating the right database connection based on configuration +- **Document Generation**: Creating different document types (PDF, Word, etc.) +- **Vehicle Manufacturing**: Creating different types of vehicles in a simulation +- **Payment Processing**: Creating different payment methods in an e-commerce application + +## Pros and Cons + +### Pros + +- Avoids tight coupling between creator and concrete products +- Single Responsibility Principle: Move product creation code to one place +- Open/Closed Principle: New products can be added without breaking existing code +- Creates objects on demand, rather than at initialization time + +### Cons + +- Code may become more complicated due to introduction of many new subclasses +- Client might be limited to the products exposed by the factory interface + +## Relations with Other Patterns + +- **Abstract Factory** classes are often implemented with Factory Methods +- **Factory Methods** are often used in Template Methods +- **Prototype** can be an alternative to Factory when the goal is to reduce subclassing +- **Builder** focuses on constructing complex objects step by step, while Factory Method is a single method call + +## Real-World Examples + +- Java's `Calendar.getInstance()` +- UI frameworks' widget factories +- Database connection factories +- Document generators in office suites + +## References + +- "Design Patterns: Elements of Reusable Object-Oriented Software" by Gang of Four (GoF) +- [Refactoring Guru - Factory Method Pattern](https://refactoring.guru/design-patterns/factory-method) +- [Refactoring Guru - Abstract Factory Pattern](https://refactoring.guru/design-patterns/abstract-factory) \ No newline at end of file diff --git a/docs/design-patterns/observer.md b/docs/design-patterns/observer.md new file mode 100644 index 0000000..b15b4b9 --- /dev/null +++ b/docs/design-patterns/observer.md @@ -0,0 +1,404 @@ +# Observer Design Pattern + +The Observer pattern is a behavioral design pattern where an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods. + +## Intent + +- Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. +- Encapsulate the core components in a Subject abstraction, and the variable components in an Observer hierarchy. +- The Subject and Observer classes can vary independently. + +## Problem + +In many applications, specific types of objects need to be informed about changes in other objects. However, we don't want to couple these different types of objects too tightly to maintain flexibility and reusability. + +You need a way for an object to notify an open-ended number of other objects about changes, without having those objects tightly coupled to each other. + +## Structure + +![Observer Pattern Structure](https://refactoring.guru/images/patterns/diagrams/observer/structure.png) + +- **Subject**: Interface or abstract class defining operations for attaching, detaching, and notifying observers. +- **ConcreteSubject**: Maintains state of interest to observers and sends notifications when state changes. +- **Observer**: Interface or abstract class with an update method that gets called when the subject's state changes. +- **ConcreteObserver**: Implements the Observer interface to keep its state consistent with the subject's state. + +## Implementation + +### Basic Implementation + +```java +// Observer interface +interface Observer { + void update(Subject subject); +} + +// Subject interface +interface Subject { + void attach(Observer observer); + void detach(Observer observer); + void notifyObservers(); +} + +// Concrete Subject +class ConcreteSubject implements Subject { + private List observers = new ArrayList<>(); + private int state; + + public int getState() { + return state; + } + + public void setState(int state) { + this.state = state; + notifyObservers(); + } + + @Override + public void attach(Observer observer) { + observers.add(observer); + } + + @Override + public void detach(Observer observer) { + observers.remove(observer); + } + + @Override + public void notifyObservers() { + for (Observer observer : observers) { + observer.update(this); + } + } +} + +// Concrete Observer +class ConcreteObserver implements Observer { + private int observerState; + + @Override + public void update(Subject subject) { + if (subject instanceof ConcreteSubject) { + observerState = ((ConcreteSubject) subject).getState(); + System.out.println("Observer state updated to: " + observerState); + } + } +} +``` + +### Push vs. Pull Models + +#### Push Model + +In the push model, the Subject sends detailed information about the change to all Observers, whether they need it or not: + +```java +// In ConcreteSubject +public void notifyObservers(int state) { + for (Observer observer : observers) { + observer.update(state); + } +} + +// In Observer interface +void update(int state); +``` + +#### Pull Model + +In the pull model, the Subject simply notifies Observers that a change occurred, and Observers are responsible for pulling the needed data: + +```java +// In ConcreteSubject +public void notifyObservers() { + for (Observer observer : observers) { + observer.update(this); + } +} + +// In Observer interface +void update(Subject subject); +``` + +## Examples in Different Languages + +### JavaScript + +```javascript +// Using ES6 classes +class Subject { + constructor() { + this.observers = []; + } + + attach(observer) { + if (!this.observers.includes(observer)) { + this.observers.push(observer); + } + } + + detach(observer) { + const index = this.observers.indexOf(observer); + if (index !== -1) { + this.observers.splice(index, 1); + } + } + + notify() { + for (const observer of this.observers) { + observer.update(this); + } + } +} + +class WeatherStation extends Subject { + constructor() { + super(); + this.temperature = 0; + this.humidity = 0; + } + + setMeasurements(temperature, humidity) { + this.temperature = temperature; + this.humidity = humidity; + this.notify(); + } + + getTemperature() { + return this.temperature; + } + + getHumidity() { + return this.humidity; + } +} + +class Observer { + update(subject) {} +} + +class DisplayDevice extends Observer { + constructor(name) { + super(); + this.name = name; + } + + update(weatherStation) { + console.log(`${this.name} Display: Temperature ${weatherStation.getTemperature()}°C, Humidity ${weatherStation.getHumidity()}%`); + } +} + +// Usage +const weatherStation = new WeatherStation(); +const phoneDisplay = new DisplayDevice('Phone'); +const laptopDisplay = new DisplayDevice('Laptop'); + +weatherStation.attach(phoneDisplay); +weatherStation.attach(laptopDisplay); + +weatherStation.setMeasurements(25, 60); // Both displays update +weatherStation.detach(laptopDisplay); +weatherStation.setMeasurements(26, 70); // Only phone display updates +``` + +### Python + +```python +from abc import ABC, abstractmethod + +# Observer interface +class Observer(ABC): + @abstractmethod + def update(self, subject): + pass + +# Subject interface +class Subject(ABC): + @abstractmethod + def attach(self, observer): + pass + + @abstractmethod + def detach(self, observer): + pass + + @abstractmethod + def notify(self): + pass + +# Concrete Subject +class NewsPublisher(Subject): + def __init__(self): + self._observers = [] + self._latest_news = None + + def attach(self, observer): + self._observers.append(observer) + + def detach(self, observer): + self._observers.remove(observer) + + def notify(self): + for observer in self._observers: + observer.update(self) + + def add_news(self, news): + self._latest_news = news + self.notify() + + @property + def latest_news(self): + return self._latest_news + +# Concrete Observer +class NewsSubscriber(Observer): + def __init__(self, name): + self._name = name + + def update(self, subject): + print(f"{self._name} received news: {subject.latest_news}") + +# Usage +if __name__ == "__main__": + publisher = NewsPublisher() + + subscriber1 = NewsSubscriber("Subscriber 1") + subscriber2 = NewsSubscriber("Subscriber 2") + + publisher.attach(subscriber1) + publisher.attach(subscriber2) + + publisher.add_news("Breaking News: Observer Pattern in Action!") + + publisher.detach(subscriber1) + + publisher.add_news("Another Update: Subscriber 1 has unsubscribed!") +``` + +### C# + +```csharp +using System; +using System.Collections.Generic; + +// Observer interface +public interface IObserver +{ + void Update(ISubject subject); +} + +// Subject interface +public interface ISubject +{ + void Attach(IObserver observer); + void Detach(IObserver observer); + void Notify(); +} + +// Concrete Subject +public class StockMarket : ISubject +{ + private List _observers = new List(); + private Dictionary _stocks = new Dictionary(); + + public void Attach(IObserver observer) + { + Console.WriteLine("StockMarket: Attached an observer."); + _observers.Add(observer); + } + + public void Detach(IObserver observer) + { + _observers.Remove(observer); + Console.WriteLine("StockMarket: Detached an observer."); + } + + public void Notify() + { + Console.WriteLine("StockMarket: Notifying observers..."); + + foreach (var observer in _observers) + { + observer.Update(this); + } + } + + public void UpdateStockPrice(string stockSymbol, double price) + { + Console.WriteLine($"StockMarket: {stockSymbol} price updated to {price}"); + _stocks[stockSymbol] = price; + Notify(); + } + + public Dictionary GetStocks() + { + return _stocks; + } +} + +// Concrete Observer +public class Investor : IObserver +{ + private string _name; + private Dictionary _watchlist = new Dictionary(); + + public Investor(string name) + { + _name = name; + } + + public void Update(ISubject subject) + { + if (subject is StockMarket stockMarket) + { + var stocks = stockMarket.GetStocks(); + foreach (var stock in stocks) + { + if (_watchlist.ContainsKey(stock.Key) && _watchlist[stock.Key] != stock.Value) + { + Console.WriteLine($"{_name}: Noticed {stock.Key} price changed from {_watchlist[stock.Key]} to {stock.Value}"); + } + _watchlist[stock.Key] = stock.Value; + } + } + } +} +``` + +## Real-World Use Cases + +1. **Event Handling Systems**: UI frameworks use Observer pattern to handle user actions. +2. **News Subscription Services**: Users subscribe to topics and receive updates. +3. **Stock Market Monitoring**: Investors monitor stock price changes. +4. **Social Media Notifications**: Users get notified about activities related to their account. +5. **Message Queue Systems**: Publishers send messages to subscribed consumers. +6. **Monitoring Systems**: Applications monitor system resources or services. + +## Pros and Cons + +### Pros + +- **Open/Closed Principle**: You can introduce new subscriber classes without changing the publisher's code. +- **Loose Coupling**: Publishers don't need to know anything about subscribers. +- **Dynamic Relationships**: Relationships between publishers and subscribers can be established at runtime. +- **Event Handling**: Effective for implementing event handling systems. + +### Cons + +- **Unexpected Updates**: Subscribers can be notified in an unpredictable order. +- **Memory Leaks**: If observers forget to unsubscribe, they might not be garbage collected. +- **Performance Overhead**: Notification can be costly if there are many observers or frequent state changes. +- **Complexity**: Debugging can be challenging because the flow of control is less obvious. + +## Relations with Other Patterns + +- **Mediator**: While Observer distributes communication by introducing subscriber and publisher objects, Mediator encapsulates the communication between objects. +- **Command**: Commands can be used to implement the Observer pattern by turning requests into objects. +- **Memento**: Can be used with Observer to undo operations after notifying observers about the changes. +- **MVC Pattern**: The Observer pattern is often used in MVC architectures where the View observes changes in the Model. + +## References + +- "Design Patterns: Elements of Reusable Object-Oriented Software" by Gang of Four (GoF) +- [Refactoring Guru - Observer Pattern](https://refactoring.guru/design-patterns/observer) +- [SourceMaking - Observer Pattern](https://sourcemaking.com/design_patterns/observer) \ No newline at end of file diff --git a/docs/design-patterns/singleton.md b/docs/design-patterns/singleton.md new file mode 100644 index 0000000..2e72e49 --- /dev/null +++ b/docs/design-patterns/singleton.md @@ -0,0 +1,226 @@ +# Singleton Design Pattern + +The Singleton pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. + +## Intent + +- Ensure a class has only one instance. +- Provide a global access point to that instance. +- Control concurrent access to shared resources. + +## Problem + +When should you use the Singleton pattern? + +- When you need exactly one instance of a class to coordinate actions across the system +- When you want to restrict the instantiation of a class to just one object +- When you need stricter control over global variables + +## Structure + +``` ++----------------+ +| Singleton | ++----------------+ +| -instance | ++----------------+ +| +getInstance() | +| -constructor() | ++----------------+ +``` + +![Singleton Pattern Structure](https://refactoring.guru/images/patterns/diagrams/singleton/structure-en.png) + +## Implementation + +### Basic Implementation + +```java +public class Singleton { + // The private static instance of the class + private static Singleton instance; + + // Private constructor prevents instantiation from other classes + private Singleton() { } + + // The public static method to get the instance + public static Singleton getInstance() { + if (instance == null) { + instance = new Singleton(); + } + return instance; + } + + // Other methods and fields + public void doSomething() { + System.out.println("Singleton is doing something"); + } +} +``` + +### Thread-Safe Implementation + +```java +public class ThreadSafeSingleton { + private static volatile ThreadSafeSingleton instance; + + private ThreadSafeSingleton() { } + + public static ThreadSafeSingleton getInstance() { + // Double-checked locking + if (instance == null) { + synchronized (ThreadSafeSingleton.class) { + if (instance == null) { + instance = new ThreadSafeSingleton(); + } + } + } + return instance; + } +} +``` + +### Eager Initialization + +```java +public class EagerSingleton { + // Instance is created at load time + private static final EagerSingleton INSTANCE = new EagerSingleton(); + + private EagerSingleton() { } + + public static EagerSingleton getInstance() { + return INSTANCE; + } +} +``` + +### Using Enum (Java) + +```java +public enum EnumSingleton { + INSTANCE; + + public void doSomething() { + System.out.println("Singleton enum is doing something"); + } +} +``` + +## Examples in Different Languages + +### JavaScript + +```javascript +class Singleton { + constructor() { + if (Singleton.instance) { + return Singleton.instance; + } + + // Initialize the singleton + this.data = []; + Singleton.instance = this; + } + + add(item) { + this.data.push(item); + } + + get(index) { + return this.data[index]; + } +} + +// Usage +const instance1 = new Singleton(); +const instance2 = new Singleton(); +console.log(instance1 === instance2); // true +``` + +### Python + +```python +class Singleton: + _instance = None + + def __new__(cls): + if cls._instance is None: + cls._instance = super(Singleton, cls).__new__(cls) + # Initialize your singleton here + cls._instance.value = 0 + return cls._instance + +# Usage +s1 = Singleton() +s2 = Singleton() +print(s1 is s2) # True +``` + +### C# + +```csharp +public sealed class Singleton +{ + private static Singleton instance = null; + private static readonly object padlock = new object(); + + Singleton() {} + + public static Singleton Instance + { + get + { + lock(padlock) + { + if (instance == null) + { + instance = new Singleton(); + } + return instance; + } + } + } +} +``` + +## Use Cases + +- **Database connections**: Manage a connection pool +- **Logger**: Create a single logging instance for an application +- **Configuration settings**: Store application settings +- **Cache**: Create a single cache manager +- **Thread pools**: Manage thread creation and assignment + +## Pros and Cons + +### Pros + +- Ensures a class has just a single instance +- Provides a global access point to that instance +- The singleton object is initialized only when it's requested for the first time + +### Cons + +- Violates the Single Responsibility Principle (the class manages its own creation) +- Can mask bad design, for instance, when components know too much about each other +- Requires special treatment in a multithreaded environment +- Makes unit testing more difficult + +## Relations with Other Patterns + +- A **Facade** might look like a Singleton if it only hides one object, but they have different purposes +- **Abstract Factories**, **Builders**, and **Prototypes** can all be implemented as Singletons + +## Real-World Examples + +- Java's `java.lang.Runtime` class +- UI Managers in many GUI frameworks +- Windows Registry +- Browser's window object + +## References + +- "Design Patterns: Elements of Reusable Object-Oriented Software" by Gang of Four (GoF) +- [Refactoring Guru - Singleton Pattern](https://refactoring.guru/design-patterns/singleton) +- [SourceMaking - Singleton Pattern](https://sourcemaking.com/design_patterns/singleton) \ No newline at end of file diff --git a/docs/devops/ci-cd.md b/docs/devops/ci-cd.md new file mode 100644 index 0000000..bdaa6f5 --- /dev/null +++ b/docs/devops/ci-cd.md @@ -0,0 +1,162 @@ +# Continuous Integration and Continuous Deployment (CI/CD) + +Continuous Integration and Continuous Deployment (CI/CD) is a method to frequently deliver apps to customers by introducing automation into the stages of app development. + +## What is CI/CD? + +### Continuous Integration (CI) +Continuous Integration is a development practice where developers integrate code into a shared repository frequently, preferably several times a day. Each integration can then be verified by an automated build and automated tests. + +### Continuous Delivery (CD) +Continuous Delivery is an extension of continuous integration to ensure that you can release new changes to your customers quickly in a sustainable way. This means that on top of having automated your testing, you also have automated your release process and you can deploy your application at any point of time by clicking a button. + +### Continuous Deployment +Continuous Deployment goes one step further than Continuous Delivery. With this practice, every change that passes all stages of your production pipeline is released to your customers. There's no human intervention, and only a failed test will prevent a new change to be deployed to production. + +## CI/CD Pipeline Components + +A typical CI/CD pipeline includes the following stages: + +1. **Source**: Code is committed to a version control system (Git, SVN, etc.) +2. **Build**: Code is compiled, dependencies are resolved +3. **Test**: Automated tests are run (unit tests, integration tests, etc.) +4. **Deploy**: Application is deployed to staging/production environments +5. **Monitor**: Application performance and errors are monitored + +## Popular CI/CD Tools + +### Jenkins + +Jenkins is an open-source automation server that enables developers to build, test, and deploy their software. + +```yaml +# Example Jenkinsfile +pipeline { + agent any + + stages { + stage('Build') { + steps { + echo 'Building..' + sh 'npm install' + } + } + stage('Test') { + steps { + echo 'Testing..' + sh 'npm test' + } + } + stage('Deploy') { + steps { + echo 'Deploying....' + sh 'npm run deploy' + } + } + } +} +``` + +### GitHub Actions + +GitHub Actions is a CI/CD platform that allows you to automate your build, test, and deployment pipeline directly from GitHub. + +```yaml +# Example GitHub Actions workflow +name: Node.js CI + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Use Node.js + uses: actions/setup-node@v1 + with: + node-version: '14.x' + - name: Install dependencies + run: npm ci + - name: Run tests + run: npm test + - name: Deploy + if: github.ref == 'refs/heads/main' + run: npm run deploy +``` + +### GitLab CI/CD + +GitLab CI/CD is a part of GitLab that allows you to apply all the continuous methods (Continuous Integration, Delivery, and Deployment) to your software. + +```yaml +# Example .gitlab-ci.yml +stages: + - build + - test + - deploy + +build: + stage: build + script: + - echo "Building the app" + - npm install + +test: + stage: test + script: + - echo "Running tests" + - npm test + +deploy: + stage: deploy + script: + - echo "Deploying application" + - npm run deploy + only: + - main +``` + +### CircleCI + +CircleCI is a cloud-based CI/CD tool that automates the software development process. + +```yaml +# Example CircleCI configuration +version: 2.1 +jobs: + build: + docker: + - image: cimg/node:14.17 + steps: + - checkout + - run: npm install + - run: npm test + - run: npm run deploy +``` + +## Best Practices for CI/CD + +1. **Automate Everything**: Automate as much of the software delivery process as possible. +2. **Fail Fast**: Detect and address issues as early as possible in the development process. +3. **Keep the Build Green**: A broken build should be the team's highest priority to fix. +4. **Build Only Once**: Build artifacts once and promote the same artifacts through the pipeline. +5. **Deploy the Same Way to Every Environment**: Use the same deployment process for all environments. +6. **Smoke Test Your Deployments**: Run basic tests after deployment to verify the system is running correctly. +7. **Keep Your CI/CD Pipeline Fast**: Aim for a pipeline that completes in less than 10 minutes. +8. **Maintain Good Test Coverage**: Ensure your tests cover most of your codebase. + +## References + +- [Martin Fowler on Continuous Integration](https://martinfowler.com/articles/continuousIntegration.html) +- [The DevOps Handbook](https://itrevolution.com/book/the-devops-handbook/) +- [Continuous Delivery](https://continuousdelivery.com/) +- [Jenkins Documentation](https://www.jenkins.io/doc/) +- [GitHub Actions Documentation](https://docs.github.com/en/actions) +- [GitLab CI/CD Documentation](https://docs.gitlab.com/ee/ci/) +- [CircleCI Documentation](https://circleci.com/docs/) diff --git a/docs/linux/bash-scripting.md b/docs/linux/bash-scripting.md new file mode 100644 index 0000000..3173040 --- /dev/null +++ b/docs/linux/bash-scripting.md @@ -0,0 +1,325 @@ +# Bash Scripting + +Bash (Bourne Again SHell) is a command language interpreter that is widely used on various operating systems, and is the default shell on most Linux distributions. + +## Introduction to Bash Scripting + +Bash scripts are text files containing a series of commands that are executed by the Bash shell. They allow you to automate repetitive tasks, combine complex commands, and create custom utilities. + +## Basic Syntax + +### Creating a Bash Script + +1. Create a file with a `.sh` extension +2. Add the shebang line at the top: `#!/bin/bash` +3. Make the script executable: `chmod +x script.sh` +4. Run the script: `./script.sh` + +### Hello World Example + +```bash +#!/bin/bash +# This is a comment +echo "Hello, World!" +``` + +## Variables + +### Variable Declaration and Usage + +```bash +#!/bin/bash + +# Variable declaration +name="John" +age=30 + +# Using variables +echo "Name: $name" +echo "Age: $age" + +# Command substitution +current_date=$(date) +echo "Current date: $current_date" + +# Arithmetic operations +result=$((10 + 5)) +echo "10 + 5 = $result" +``` + +### Special Variables + +| Variable | Description | +|----------|-------------| +| `$0` | The name of the script | +| `$1` to `$9` | The first 9 arguments passed to the script | +| `$#` | The number of arguments passed to the script | +| `$@` | All arguments passed to the script | +| `$?` | The exit status of the last command | +| `$$` | The process ID of the current script | +| `$USER` | The username of the user running the script | +| `$HOSTNAME` | The hostname of the machine | +| `$RANDOM` | A random number | +| `$HOME` | The home directory of the user | + +## Control Structures + +### Conditional Statements + +#### If-Else Statement + +```bash +#!/bin/bash + +age=25 + +if [ $age -lt 18 ]; then + echo "You are a minor." +elif [ $age -ge 18 ] && [ $age -lt 65 ]; then + echo "You are an adult." +else + echo "You are a senior." +fi +``` + +#### Case Statement + +```bash +#!/bin/bash + +fruit="apple" + +case $fruit in + "apple") + echo "This is an apple." + ;; + "banana") + echo "This is a banana." + ;; + "orange") + echo "This is an orange." + ;; + *) + echo "Unknown fruit." + ;; +esac +``` + +### Loops + +#### For Loop + +```bash +#!/bin/bash + +# Simple for loop +for i in 1 2 3 4 5; do + echo "Number: $i" +done + +# For loop with range +for i in {1..5}; do + echo "Number: $i" +done + +# For loop with step +for i in {1..10..2}; do + echo "Odd number: $i" +done + +# For loop with command output +for file in $(ls); do + echo "File: $file" +done +``` + +#### While Loop + +```bash +#!/bin/bash + +count=1 + +while [ $count -le 5 ]; do + echo "Count: $count" + ((count++)) +done +``` + +#### Until Loop + +```bash +#!/bin/bash + +count=1 + +until [ $count -gt 5 ]; do + echo "Count: $count" + ((count++)) +done +``` + +## Functions + +### Function Definition and Usage + +```bash +#!/bin/bash + +# Function definition +greet() { + echo "Hello, $1!" +} + +# Function with return value +add() { + local result=$(($1 + $2)) + echo $result +} + +# Function calls +greet "John" +sum=$(add 5 3) +echo "5 + 3 = $sum" +``` + +## Input and Output + +### Reading User Input + +```bash +#!/bin/bash + +# Read a single value +echo "Enter your name:" +read name +echo "Hello, $name!" + +# Read multiple values +echo "Enter your first and last name:" +read first_name last_name +echo "Hello, $first_name $last_name!" + +# Read with prompt +read -p "Enter your age: " age +echo "You are $age years old." + +# Read password (hidden input) +read -sp "Enter your password: " password +echo -e "\nPassword received." +``` + +### File Input/Output + +```bash +#!/bin/bash + +# Writing to a file +echo "Hello, World!" > output.txt +echo "This is a new line." >> output.txt + +# Reading from a file +while IFS= read -r line; do + echo "Line: $line" +done < input.txt + +# Process each line of a file +cat input.txt | while read line; do + echo "Processing: $line" +done +``` + +## Arrays + +### Array Operations + +```bash +#!/bin/bash + +# Declare an array +fruits=("apple" "banana" "orange" "grape") + +# Access array elements +echo "First fruit: ${fruits[0]}" +echo "All fruits: ${fruits[@]}" +echo "Number of fruits: ${#fruits[@]}" + +# Iterate through array +for fruit in "${fruits[@]}"; do + echo "Fruit: $fruit" +done + +# Add element to array +fruits+=("kiwi") + +# Remove element from array +unset fruits[1] +``` + +## String Manipulation + +### String Operations + +```bash +#!/bin/bash + +# String length +str="Hello, World!" +echo "Length: ${#str}" + +# Substring +echo "Substring: ${str:7:5}" + +# String replacement +echo "Replace: ${str/World/Bash}" + +# Convert to uppercase/lowercase +echo "Uppercase: ${str^^}" +echo "Lowercase: ${str,,}" +``` + +## Error Handling + +### Basic Error Handling + +```bash +#!/bin/bash + +# Exit on error +set -e + +# Custom error handling +handle_error() { + echo "Error occurred at line $1" + exit 1 +} + +# Trap errors +trap 'handle_error $LINENO' ERR + +# Check command success +if ! command -v git &> /dev/null; then + echo "Git is not installed." + exit 1 +fi +``` + +## Best Practices + +1. **Use Shebang**: Always include `#!/bin/bash` at the top of your scripts. +2. **Comments**: Add comments to explain complex logic. +3. **Error Handling**: Implement proper error handling. +4. **Indentation**: Use consistent indentation for readability. +5. **Naming Conventions**: Use descriptive names for variables and functions. +6. **Quoting Variables**: Always quote variables to handle spaces and special characters. +7. **Exit Codes**: Return appropriate exit codes. +8. **Modularity**: Break complex scripts into functions. +9. **Debugging**: Use `set -x` for debugging. +10. **Testing**: Test your scripts with different inputs. + +## References + +- [GNU Bash Manual](https://www.gnu.org/software/bash/manual/) +- [Bash Guide for Beginners](https://tldp.org/LDP/Bash-Beginners-Guide/html/) +- [Advanced Bash-Scripting Guide](https://tldp.org/LDP/abs/html/) +- [ShellCheck](https://www.shellcheck.net/) - A shell script analysis tool diff --git a/docs/system-design/microservices.md b/docs/system-design/microservices.md new file mode 100644 index 0000000..df86b54 --- /dev/null +++ b/docs/system-design/microservices.md @@ -0,0 +1,467 @@ +# Microservices Architecture + +Microservices architecture is an architectural style that structures an application as a collection of small, loosely coupled services that can be developed, deployed, and scaled independently. + +## What are Microservices? + +Microservices are small, autonomous services that work together to form a complete application. Each microservice: + +- Focuses on a single business capability +- Runs in its own process +- Communicates via well-defined APIs +- Can be deployed independently +- Can be written in different programming languages +- Can use different data storage technologies + +## Monolithic vs. Microservices Architecture + +| Aspect | Monolithic | Microservices | +|--------|------------|---------------| +| Structure | Single, unified codebase | Multiple, independent services | +| Development | Simpler to develop initially | More complex initial setup | +| Deployment | Deploy entire application | Deploy individual services | +| Scaling | Scale entire application | Scale individual services as needed | +| Technology | Single technology stack | Multiple technology stacks possible | +| Team Structure | Larger teams working on same codebase | Smaller teams working on individual services | +| Failure Impact | Single point of failure | Isolated failures | +| Data Management | Shared database | Database per service | + +## Key Principles of Microservices + +1. **Single Responsibility**: Each service is responsible for a specific business capability. +2. **Autonomy**: Services can be developed, deployed, and scaled independently. +3. **Resilience**: Failure in one service should not cascade to others. +4. **Decentralization**: Decentralized governance and data management. +5. **Continuous Delivery**: Frequent, automated deployment of individual services. +6. **Observability**: Comprehensive monitoring and logging. +7. **Domain-Driven Design**: Services are designed around business domains. + +## Microservices Communication Patterns + +### Synchronous Communication + +#### REST API + +```json +// Example REST API request +GET /api/products/123 +Accept: application/json + +// Example response +{ + "id": "123", + "name": "Product Name", + "price": 19.99, + "category": "Electronics" +} +``` + +#### gRPC + +```protobuf +// Example gRPC service definition +syntax = "proto3"; + +service ProductService { + rpc GetProduct(ProductRequest) returns (Product); +} + +message ProductRequest { + string id = 1; +} + +message Product { + string id = 1; + string name = 2; + double price = 3; + string category = 4; +} +``` + +### Asynchronous Communication + +#### Message Queue + +```javascript +// Example message producer (Node.js with RabbitMQ) +const amqp = require('amqplib'); + +async function sendOrderCreatedEvent(order) { + const connection = await amqp.connect('amqp://localhost'); + const channel = await connection.createChannel(); + + const queue = 'order_events'; + const message = JSON.stringify({ + type: 'ORDER_CREATED', + data: order + }); + + await channel.assertQueue(queue, { durable: true }); + channel.sendToQueue(queue, Buffer.from(message)); + + console.log(`Sent: ${message}`); + + setTimeout(() => { + connection.close(); + }, 500); +} +``` + +```javascript +// Example message consumer (Node.js with RabbitMQ) +const amqp = require('amqplib'); + +async function processOrderEvents() { + const connection = await amqp.connect('amqp://localhost'); + const channel = await connection.createChannel(); + + const queue = 'order_events'; + + await channel.assertQueue(queue, { durable: true }); + console.log(`Waiting for messages in ${queue}`); + + channel.consume(queue, (msg) => { + const event = JSON.parse(msg.content.toString()); + console.log(`Received: ${event.type}`); + + if (event.type === 'ORDER_CREATED') { + // Process the order + processOrder(event.data); + } + + channel.ack(msg); + }); +} +``` + +#### Event Streaming + +```java +// Example Kafka producer (Java) +Properties props = new Properties(); +props.put("bootstrap.servers", "localhost:9092"); +props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); +props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); + +Producer producer = new KafkaProducer<>(props); + +String topic = "order-events"; +String key = order.getId(); +String value = objectMapper.writeValueAsString(order); + +ProducerRecord record = new ProducerRecord<>(topic, key, value); +producer.send(record); +producer.close(); +``` + +```java +// Example Kafka consumer (Java) +Properties props = new Properties(); +props.put("bootstrap.servers", "localhost:9092"); +props.put("group.id", "order-processing-group"); +props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); +props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); + +Consumer consumer = new KafkaConsumer<>(props); +consumer.subscribe(Arrays.asList("order-events")); + +while (true) { + ConsumerRecords records = consumer.poll(Duration.ofMillis(100)); + for (ConsumerRecord record : records) { + String key = record.key(); + String value = record.value(); + + Order order = objectMapper.readValue(value, Order.class); + processOrder(order); + } +} +``` + +## Service Discovery and API Gateway + +### Service Discovery + +```yaml +# Example Consul service registration +{ + "service": { + "name": "product-service", + "id": "product-service-1", + "tags": ["api", "v1"], + "address": "10.0.0.1", + "port": 8080, + "checks": [ + { + "http": "http://10.0.0.1:8080/health", + "interval": "10s" + } + ] + } +} +``` + +### API Gateway + +```yaml +# Example Kong API Gateway configuration +services: + - name: product-service + url: http://product-service:8080 + routes: + - name: product-routes + paths: + - /api/products + strip_path: true + plugins: + - name: rate-limiting + config: + minute: 100 + - name: jwt +``` + +## Data Management in Microservices + +### Database per Service + +```yaml +# Example docker-compose.yml for multiple databases +version: '3' +services: + product-service: + build: ./product-service + depends_on: + - product-db + environment: + - DB_HOST=product-db + - DB_PORT=5432 + - DB_NAME=productdb + + product-db: + image: postgres:13 + environment: + - POSTGRES_DB=productdb + - POSTGRES_USER=user + - POSTGRES_PASSWORD=password + volumes: + - product-db-data:/var/lib/postgresql/data + + order-service: + build: ./order-service + depends_on: + - order-db + environment: + - DB_HOST=order-db + - DB_PORT=27017 + - DB_NAME=orderdb + + order-db: + image: mongo:4.4 + environment: + - MONGO_INITDB_DATABASE=orderdb + volumes: + - order-db-data:/data/db + +volumes: + product-db-data: + order-db-data: +``` + +### CQRS Pattern + +```csharp +// Command side +public class CreateOrderCommand +{ + public string CustomerId { get; set; } + public List Items { get; set; } +} + +public class OrderCommandHandler +{ + private readonly IOrderRepository _repository; + private readonly IEventBus _eventBus; + + public OrderCommandHandler(IOrderRepository repository, IEventBus eventBus) + { + _repository = repository; + _eventBus = eventBus; + } + + public async Task Handle(CreateOrderCommand command) + { + var order = new Order(Guid.NewGuid(), command.CustomerId, command.Items); + await _repository.SaveAsync(order); + + await _eventBus.PublishAsync(new OrderCreatedEvent + { + OrderId = order.Id, + CustomerId = order.CustomerId, + Items = order.Items + }); + } +} + +// Query side +public class OrderQueryService +{ + private readonly IOrderReadModel _readModel; + + public OrderQueryService(IOrderReadModel readModel) + { + _readModel = readModel; + } + + public async Task GetOrderAsync(Guid orderId) + { + return await _readModel.GetOrderAsync(orderId); + } + + public async Task> GetCustomerOrdersAsync(string customerId) + { + return await _readModel.GetCustomerOrdersAsync(customerId); + } +} +``` + +## Deploying Microservices + +### Docker Containers + +```dockerfile +# Example Dockerfile for a microservice +FROM node:14-alpine + +WORKDIR /app + +COPY package*.json ./ +RUN npm install --production + +COPY . . + +EXPOSE 8080 + +CMD ["node", "server.js"] +``` + +### Kubernetes + +```yaml +# Example Kubernetes deployment for a microservice +apiVersion: apps/v1 +kind: Deployment +metadata: + name: product-service + labels: + app: product-service +spec: + replicas: 3 + selector: + matchLabels: + app: product-service + template: + metadata: + labels: + app: product-service + spec: + containers: + - name: product-service + image: my-registry/product-service:1.0.0 + ports: + - containerPort: 8080 + env: + - name: DB_HOST + value: product-db-service + - name: DB_PORT + value: "5432" + - name: DB_NAME + value: productdb + livenessProbe: + httpGet: + path: /health + port: 8080 + initialDelaySeconds: 30 + periodSeconds: 10 +--- +apiVersion: v1 +kind: Service +metadata: + name: product-service +spec: + selector: + app: product-service + ports: + - port: 80 + targetPort: 8080 + type: ClusterIP +``` + +## Monitoring and Observability + +### Distributed Tracing + +```java +// Example using Spring Cloud Sleuth and Zipkin +@RestController +public class ProductController { + + private final ProductService productService; + + @Autowired + public ProductController(ProductService productService) { + this.productService = productService; + } + + @GetMapping("/products/{id}") + public Product getProduct(@PathVariable String id) { + // Tracing is automatically handled by Sleuth + return productService.getProduct(id); + } +} +``` + +### Metrics Collection + +```yaml +# Example Prometheus configuration +global: + scrape_interval: 15s + +scrape_configs: + - job_name: 'product-service' + metrics_path: '/actuator/prometheus' + static_configs: + - targets: ['product-service:8080'] + + - job_name: 'order-service' + metrics_path: '/actuator/prometheus' + static_configs: + - targets: ['order-service:8080'] +``` + +## Challenges and Best Practices + +### Challenges + +1. **Distributed System Complexity**: Debugging and testing become more difficult. +2. **Data Consistency**: Maintaining consistency across services is challenging. +3. **Service Boundaries**: Defining the right service boundaries requires domain expertise. +4. **Operational Overhead**: More services mean more infrastructure to manage. +5. **Network Latency**: Communication between services adds latency. + +### Best Practices + +1. **Start Monolithic**: Begin with a monolith and extract microservices as needed. +2. **Design for Failure**: Implement circuit breakers, retries, and fallbacks. +3. **Automate Everything**: Use CI/CD pipelines for all services. +4. **Implement Monitoring**: Comprehensive logging, metrics, and tracing. +5. **Use Containers**: Containerize services for consistency across environments. +6. **API Versioning**: Implement proper API versioning to manage changes. +7. **Documentation**: Maintain clear documentation for all services and APIs. +8. **Testing**: Implement comprehensive testing strategies, including contract testing. + +## References + +- [Microservices.io](https://microservices.io/) +- [Martin Fowler on Microservices](https://martinfowler.com/articles/microservices.html) +- [Sam Newman - Building Microservices](https://samnewman.io/books/building_microservices/) +- [Chris Richardson - Microservices Patterns](https://microservices.io/book) diff --git a/docs/testing/unit-testing.md b/docs/testing/unit-testing.md new file mode 100644 index 0000000..600021c --- /dev/null +++ b/docs/testing/unit-testing.md @@ -0,0 +1,467 @@ +# Unit Testing + +Unit testing is a software testing method where individual units or components of a software are tested in isolation from the rest of the system. + +## What is Unit Testing? + +A unit test verifies that a small, isolated piece of code (a "unit") behaves exactly as the developer expects. Units are typically: + +- Individual functions or methods +- Classes +- Modules or components + +The goal is to validate that each unit of the software performs as designed. + +## Benefits of Unit Testing + +- **Early Bug Detection**: Catch bugs early in the development cycle +- **Facilitates Changes**: Makes it easier to refactor code and add new features +- **Documentation**: Tests serve as documentation for how the code should behave +- **Design Improvement**: Encourages better software design and modularity +- **Confidence**: Provides confidence that the code works as expected +- **Reduces Costs**: Cheaper to fix bugs found during unit testing than later stages + +## Unit Testing Principles + +### FIRST Principles + +- **Fast**: Tests should run quickly +- **Independent**: Tests should not depend on each other +- **Repeatable**: Tests should yield the same results every time +- **Self-validating**: Tests should automatically determine if they pass or fail +- **Timely**: Tests should be written at the right time (ideally before the code) + +### AAA Pattern + +- **Arrange**: Set up the test conditions +- **Act**: Execute the code being tested +- **Assert**: Verify the result is as expected + +## Unit Testing Frameworks + +### JavaScript (Jest) + +```javascript +// math.js +function add(a, b) { + return a + b; +} + +function subtract(a, b) { + return a - b; +} + +module.exports = { add, subtract }; + +// math.test.js +const { add, subtract } = require('./math'); + +describe('Math functions', () => { + test('add should correctly add two numbers', () => { + // Arrange + const a = 5; + const b = 3; + + // Act + const result = add(a, b); + + // Assert + expect(result).toBe(8); + }); + + test('subtract should correctly subtract two numbers', () => { + // Arrange + const a = 5; + const b = 3; + + // Act + const result = subtract(a, b); + + // Assert + expect(result).toBe(2); + }); +}); +``` + +### Python (pytest) + +```python +# math_utils.py +def add(a, b): + return a + b + +def subtract(a, b): + return a - b + +# test_math_utils.py +import pytest +from math_utils import add, subtract + +def test_add(): + # Arrange + a = 5 + b = 3 + + # Act + result = add(a, b) + + # Assert + assert result == 8 + +def test_subtract(): + # Arrange + a = 5 + b = 3 + + # Act + result = subtract(a, b) + + # Assert + assert result == 2 +``` + +### Java (JUnit) + +```java +// MathUtils.java +public class MathUtils { + public int add(int a, int b) { + return a + b; + } + + public int subtract(int a, int b) { + return a - b; + } +} + +// MathUtilsTest.java +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.Test; + +public class MathUtilsTest { + + @Test + public void testAdd() { + // Arrange + MathUtils mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.add(a, b); + + // Assert + assertEquals(8, result); + } + + @Test + public void testSubtract() { + // Arrange + MathUtils mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.subtract(a, b); + + // Assert + assertEquals(2, result); + } +} +``` + +### C# (xUnit) + +```csharp +// MathUtils.cs +public class MathUtils +{ + public int Add(int a, int b) + { + return a + b; + } + + public int Subtract(int a, int b) + { + return a - b; + } +} + +// MathUtilsTests.cs +using Xunit; + +public class MathUtilsTests +{ + [Fact] + public void Add_ShouldCorrectlyAddTwoNumbers() + { + // Arrange + var mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.Add(a, b); + + // Assert + Assert.Equal(8, result); + } + + [Fact] + public void Subtract_ShouldCorrectlySubtractTwoNumbers() + { + // Arrange + var mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.Subtract(a, b); + + // Assert + Assert.Equal(2, result); + } +} +``` + +## Test Doubles + +Test doubles are objects that replace real components in tests to isolate the code being tested. + +### Types of Test Doubles + +#### Dummy + +Objects that are passed around but never actually used. + +```javascript +// JavaScript example +function createUser(user, logger) { + // logger is not used in this test + return { id: 123, ...user }; +} + +test('createUser should add an ID to the user', () => { + // Arrange + const dummyLogger = {}; // Dummy object that's never used + const user = { name: 'John' }; + + // Act + const result = createUser(user, dummyLogger); + + // Assert + expect(result.id).toBeDefined(); + expect(result.name).toBe('John'); +}); +``` + +#### Stub + +Objects that provide predefined answers to calls made during the test. + +```java +// Java example +public interface WeatherService { + int getCurrentTemperature(String city); +} + +// Stub implementation +public class WeatherServiceStub implements WeatherService { + @Override + public int getCurrentTemperature(String city) { + return 25; // Always returns 25°C regardless of the city + } +} + +@Test +public void testWeatherReporter() { + // Arrange + WeatherService stubService = new WeatherServiceStub(); + WeatherReporter reporter = new WeatherReporter(stubService); + + // Act + String report = reporter.generateReport("London"); + + // Assert + assertEquals("Current temperature in London: 25°C", report); +} +``` + +#### Spy + +Objects that record calls made to them. + +```python +# Python example +class EmailServiceSpy: + def __init__(self): + self.emails_sent = [] + + def send_email(self, to, subject, body): + self.emails_sent.append({ + 'to': to, + 'subject': subject, + 'body': body + }) + +def test_user_registration_sends_welcome_email(): + # Arrange + email_service = EmailServiceSpy() + user_service = UserService(email_service) + + # Act + user_service.register("john@example.com", "password123") + + # Assert + assert len(email_service.emails_sent) == 1 + assert email_service.emails_sent[0]['to'] == "john@example.com" + assert "Welcome" in email_service.emails_sent[0]['subject'] +``` + +#### Mock + +Objects that verify that specific methods were called with specific arguments. + +```csharp +// C# example with Moq +[Fact] +public void Register_ShouldSendWelcomeEmail() +{ + // Arrange + var mockEmailService = new Mock(); + var userService = new UserService(mockEmailService.Object); + + // Act + userService.Register("john@example.com", "password123"); + + // Assert + mockEmailService.Verify( + x => x.SendEmail( + "john@example.com", + It.Is(s => s.Contains("Welcome")), + It.IsAny() + ), + Times.Once + ); +} +``` + +#### Fake + +Objects that have working implementations but are not suitable for production. + +```javascript +// JavaScript example +class FakeUserRepository { + constructor() { + this.users = []; + this.nextId = 1; + } + + create(userData) { + const user = { id: this.nextId++, ...userData }; + this.users.push(user); + return user; + } + + findById(id) { + return this.users.find(user => user.id === id); + } +} + +test('UserService should create a user', () => { + // Arrange + const fakeRepo = new FakeUserRepository(); + const userService = new UserService(fakeRepo); + + // Act + const user = userService.createUser('John', 'john@example.com'); + + // Assert + expect(user.id).toBe(1); + expect(user.name).toBe('John'); + expect(fakeRepo.findById(1)).toEqual(user); +}); +``` + +## Test Coverage + +Test coverage measures how much of your code is executed during tests. + +### Coverage Metrics + +- **Line Coverage**: Percentage of lines executed during tests +- **Branch Coverage**: Percentage of branches (if/else, switch) executed during tests +- **Function Coverage**: Percentage of functions called during tests +- **Statement Coverage**: Percentage of statements executed during tests + +### Example Coverage Report (Jest) + +``` +--------------------|---------|----------|---------|---------|------------------- +File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s +--------------------|---------|----------|---------|---------|------------------- +All files | 85.71 | 66.67 | 100 | 85.71 | + math.js | 100 | 100 | 100 | 100 | + string-utils.js | 71.43 | 33.33 | 100 | 71.43 | 15-18 +--------------------|---------|----------|---------|---------|------------------- +``` + +## Best Practices for Unit Testing + +1. **Test One Thing at a Time**: Each test should verify one specific behavior. +2. **Keep Tests Simple**: Tests should be easy to understand and maintain. +3. **Use Descriptive Test Names**: Names should clearly describe what is being tested. +4. **Isolate the Unit**: Use test doubles to isolate the unit from its dependencies. +5. **Test Edge Cases**: Include tests for boundary conditions and error cases. +6. **Don't Test the Framework**: Focus on testing your code, not the framework or language. +7. **Maintain Test Independence**: Tests should not depend on each other or run in a specific order. +8. **Avoid Logic in Tests**: Tests should be straightforward with minimal logic. +9. **Write Tests First (TDD)**: Consider writing tests before implementing the code. +10. **Refactor Tests**: Keep tests clean and maintainable, just like production code. + +## Test-Driven Development (TDD) + +TDD is a development process where tests are written before the code. The cycle is: + +1. **Red**: Write a failing test +2. **Green**: Write the minimal code to make the test pass +3. **Refactor**: Improve the code while keeping the tests passing + +### TDD Example (JavaScript) + +```javascript +// Step 1: Write a failing test +test('isPalindrome should return true for palindromes', () => { + expect(isPalindrome('racecar')).toBe(true); +}); + +// Step 2: Write minimal code to make it pass +function isPalindrome(str) { + return str === str.split('').reverse().join(''); +} + +// Step 3: Add more tests +test('isPalindrome should return false for non-palindromes', () => { + expect(isPalindrome('hello')).toBe(false); +}); + +test('isPalindrome should be case insensitive', () => { + expect(isPalindrome('Racecar')).toBe(true); +}); + +// Step 4: Refactor the code +function isPalindrome(str) { + const normalized = str.toLowerCase(); + return normalized === normalized.split('').reverse().join(''); +} +``` + +## References + +- [Martin Fowler on Unit Testing](https://martinfowler.com/bliki/UnitTest.html) +- [Test-Driven Development by Example](https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530) +- [Jest Documentation](https://jestjs.io/docs/getting-started) +- [pytest Documentation](https://docs.pytest.org/) +- [JUnit Documentation](https://junit.org/junit5/docs/current/user-guide/) +- [xUnit Documentation](https://xunit.net/docs/getting-started/netcore/cmdline) diff --git a/i18n/es/init.txt b/i18n/es/init.txt new file mode 100644 index 0000000..e69de29 diff --git a/i18n/vi/algorithms/graph-traversal_vi.md b/i18n/vi/algorithms/graph-traversal_vi.md new file mode 100644 index 0000000..d41c6f1 --- /dev/null +++ b/i18n/vi/algorithms/graph-traversal_vi.md @@ -0,0 +1,148 @@ +# Các Thuật Toán Duyệt Đồ Thị (Graph Traversal Algorithms) + +Các thuật toán duyệt đồ thị là những kỹ thuật cơ bản được sử dụng để thăm mỗi đỉnh trong một đồ thị. Chúng là nền tảng cho nhiều thuật toán đồ thị phức tạp hơn. + +## Mục Lục + +- [Tìm Kiếm Theo Chiều Rộng (BFS)](#tìm-kiếm-theo-chiều-rộng-bfs) +- [Tìm Kiếm Theo Chiều Sâu (DFS)](#tìm-kiếm-theo-chiều-sâu-dfs) +- [So Sánh BFS và DFS](#so-sánh-bfs-và-dfs) +- [Ứng Dụng](#ứng-dụng) +- [Độ Phức Tạp Về Thời Gian và Không Gian](#độ-phức-tạp-về-thời-gian-và-không-gian) + +## Tìm Kiếm Theo Chiều Rộng (BFS) + +Tìm kiếm theo chiều rộng là một thuật toán duyệt đồ thị khám phá tất cả các đỉnh ở mức độ sâu hiện tại trước khi di chuyển đến các đỉnh ở mức độ sâu tiếp theo. + +### Cách Hoạt Động của BFS + +1. Bắt đầu từ một đỉnh nguồn và đánh dấu nó là đã thăm +2. Thăm tất cả các đỉnh kề chưa thăm và đánh dấu chúng là đã thăm +3. Đối với mỗi đỉnh kề đó, thăm tất cả các đỉnh kề chưa thăm của chúng +4. Lặp lại cho đến khi tất cả các đỉnh đã được thăm + +### Cài Đặt + +```python +from collections import deque + +def bfs(graph, start): + visited = set([start]) + queue = deque([start]) + result = [] + + while queue: + vertex = queue.popleft() + result.append(vertex) + + for neighbor in graph[vertex]: + if neighbor not in visited: + visited.add(neighbor) + queue.append(neighbor) + + return result + +# Ví dụ sử dụng +graph = { + 'A': ['B', 'C'], + 'B': ['A', 'D', 'E'], + 'C': ['A', 'F'], + 'D': ['B'], + 'E': ['B', 'F'], + 'F': ['C', 'E'] +} + +print(bfs(graph, 'A')) # Kết quả: ['A', 'B', 'C', 'D', 'E', 'F'] +``` + +## Tìm Kiếm Theo Chiều Sâu (DFS) + +Tìm kiếm theo chiều sâu là một thuật toán duyệt đồ thị khám phá càng xa càng tốt dọc theo mỗi nhánh trước khi quay lui. + +### Cách Hoạt Động của DFS + +1. Bắt đầu từ một đỉnh nguồn và đánh dấu nó là đã thăm +2. Đệ quy thăm một trong các đỉnh kề chưa thăm của nó +3. Tiếp tục quá trình này, đi sâu hơn vào đồ thị +4. Khi bạn đến một đỉnh không có đỉnh kề chưa thăm, quay lui + +### Cài Đặt + +```python +def dfs_recursive(graph, vertex, visited=None, result=None): + if visited is None: + visited = set() + if result is None: + result = [] + + visited.add(vertex) + result.append(vertex) + + for neighbor in graph[vertex]: + if neighbor not in visited: + dfs_recursive(graph, neighbor, visited, result) + + return result + +# Cài đặt lặp sử dụng ngăn xếp +def dfs_iterative(graph, start): + visited = set() + stack = [start] + result = [] + + while stack: + vertex = stack.pop() + if vertex not in visited: + visited.add(vertex) + result.append(vertex) + + # Thêm các đỉnh kề theo thứ tự ngược lại để mô phỏng DFS đệ quy + for neighbor in reversed(graph[vertex]): + if neighbor not in visited: + stack.append(neighbor) + + return result + +# Ví dụ sử dụng (cùng đồ thị như ví dụ BFS) +print(dfs_recursive(graph, 'A')) # Kết quả có thể là: ['A', 'B', 'D', 'E', 'F', 'C'] +print(dfs_iterative(graph, 'A')) # Kết quả tương tự, có thể thay đổi tùy thuộc vào thứ tự đỉnh kề +``` + +## So Sánh BFS và DFS + +| Khía cạnh | BFS | DFS | +|-----------|-----|-----| +| Cấu trúc dữ liệu | Hàng đợi (Queue) | Ngăn xếp (Stack) hoặc đệ quy | +| Độ phức tạp không gian | O(b^d) với b là hệ số phân nhánh và d là khoảng cách từ nguồn | O(h) với h là chiều cao của cây | +| Tính đầy đủ | Đầy đủ (tìm tất cả các đỉnh ở độ sâu nhất định trước khi đi sâu hơn) | Không đầy đủ cho đồ thị vô hạn | +| Tính tối ưu | Tối ưu cho đồ thị không có trọng số | Không tối ưu nói chung | +| Trường hợp sử dụng | Đường đi ngắn nhất trong đồ thị không trọng số, duyệt theo cấp | Sắp xếp tô-pô, phát hiện chu trình, tìm đường đi | + +## Ứng Dụng + +- **Ứng Dụng của BFS**: + - Tìm đường đi ngắn nhất trong đồ thị không trọng số + - Tìm tất cả các đỉnh trong một thành phần liên thông + - Kiểm tra tính hai phía của đồ thị + - Bộ thu thập thông tin web (Web crawlers) + - Tính năng mạng xã hội (ví dụ: "Bạn bè trong vòng 2 kết nối") + +- **Ứng Dụng của DFS**: + - Sắp xếp tô-pô + - Tìm thành phần liên thông mạnh + - Giải các câu đố chỉ có một lời giải (ví dụ: mê cung) + - Phát hiện chu trình + - Tìm đường đi trong trò chơi và câu đố + +## Độ Phức Tạp Về Thời Gian và Không Gian + +Cả BFS và DFS đều có độ phức tạp thời gian là O(V + E) với V là số đỉnh và E là số cạnh. Điều này là do trong trường hợp xấu nhất, mỗi đỉnh và mỗi cạnh sẽ được khám phá một lần. + +Độ phức tạp không gian: +- BFS: O(V) trong trường hợp xấu nhất khi tất cả các đỉnh được lưu trữ trong hàng đợi +- DFS: O(h) với h là độ sâu tối đa của ngăn xếp đệ quy (có thể là O(V) trong trường hợp xấu nhất) + +## Tài Liệu Tham Khảo + +1. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press. +2. Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley Professional. \ No newline at end of file diff --git a/i18n/vi/databases/relational_vi.md b/i18n/vi/databases/relational_vi.md new file mode 100644 index 0000000..6647b44 --- /dev/null +++ b/i18n/vi/databases/relational_vi.md @@ -0,0 +1,117 @@ +# Cơ sở dữ liệu quan hệ + +Cơ sở dữ liệu quan hệ là tập hợp dữ liệu có tổ chức lưu trữ thông tin trong các bảng với hàng và cột. Chúng tuân theo mô hình quan hệ do Edgar F. Codd đề xuất vào năm 1970, nhấn mạnh mối quan hệ giữa các thực thể dữ liệu. + +## Khái niệm cốt lõi + +### Bảng (Relations) + +Cấu trúc cơ bản trong cơ sở dữ liệu quan hệ: +- Mỗi **bảng** đại diện cho một loại thực thể (ví dụ: khách hàng, sản phẩm) +- Mỗi **hàng** (tuple) đại diện cho một thể hiện của thực thể đó +- Mỗi **cột** (thuộc tính) đại diện cho một thuộc tính của thực thể đó + +### Khóa + +Khóa thiết lập mối quan hệ và đảm bảo tính toàn vẹn dữ liệu: + +- **Khóa chính (Primary Key)**: Xác định duy nhất mỗi bản ghi trong bảng +- **Khóa ngoại (Foreign Key)**: Tham chiếu đến khóa chính trong bảng khác, thiết lập mối quan hệ +- **Khóa tổng hợp (Composite Key)**: Kết hợp nhiều cột để tạo thành định danh duy nhất +- **Khóa ứng viên (Candidate Key)**: Cột hoặc tập hợp các cột có thể đóng vai trò làm khóa chính + +### Lược đồ (Schema) + +Lược đồ xác định cấu trúc của cơ sở dữ liệu: +- Định nghĩa bảng +- Kiểu dữ liệu và ràng buộc cột +- Mối quan hệ giữa các bảng + +## SQL (Ngôn ngữ truy vấn có cấu trúc) + +SQL là ngôn ngữ tiêu chuẩn để tương tác với cơ sở dữ liệu quan hệ. + +### Các lệnh SQL cơ bản + +```sql +-- Tạo bảng +CREATE TABLE customers ( + customer_id INT PRIMARY KEY, + name VARCHAR(100), + email VARCHAR(100), + signup_date DATE +); + +-- Chèn dữ liệu +INSERT INTO customers (customer_id, name, email, signup_date) +VALUES (1, 'Nguyễn Văn A', 'nguyenvana@example.com', '2023-01-15'); + +-- Truy vấn dữ liệu +SELECT * FROM customers WHERE signup_date > '2023-01-01'; + +-- Cập nhật dữ liệu +UPDATE customers SET email = 'nguyenvana.new@example.com' WHERE customer_id = 1; + +-- Xóa dữ liệu +DELETE FROM customers WHERE customer_id = 1; +``` + +## Chuẩn hóa + +Chuẩn hóa là quá trình tổ chức dữ liệu để giảm dư thừa và cải thiện tính toàn vẹn dữ liệu: + +- **Dạng chuẩn 1 (1NF)**: Loại bỏ các cột trùng lặp và tạo bảng riêng cho dữ liệu liên quan +- **Dạng chuẩn 2 (2NF)**: Đáp ứng yêu cầu 1NF và loại bỏ phụ thuộc một phần +- **Dạng chuẩn 3 (3NF)**: Đáp ứng yêu cầu 2NF và loại bỏ phụ thuộc bắc cầu + +## Tính chất ACID + +Các giao dịch trong cơ sở dữ liệu quan hệ tuân theo tính chất ACID: + +- **Tính nguyên tử (Atomicity)**: Giao dịch là các hoạt động tất cả hoặc không có gì +- **Tính nhất quán (Consistency)**: Giao dịch đưa cơ sở dữ liệu từ trạng thái hợp lệ này sang trạng thái hợp lệ khác +- **Tính cô lập (Isolation)**: Các giao dịch đồng thời không ảnh hưởng đến nhau +- **Tính bền vững (Durability)**: Giao dịch hoàn thành vẫn tồn tại ngay cả khi hệ thống gặp sự cố + +## Các hệ thống cơ sở dữ liệu quan hệ phổ biến + +- **MySQL**: Mã nguồn mở, được sử dụng rộng rãi cho các ứng dụng web +- **PostgreSQL**: Cơ sở dữ liệu mã nguồn mở nâng cao với nhiều tính năng mở rộng +- **Oracle Database**: Cơ sở dữ liệu thương mại cấp doanh nghiệp +- **Microsoft SQL Server**: Giải pháp cơ sở dữ liệu thương mại của Microsoft +- **SQLite**: Động cơ cơ sở dữ liệu nhẹ, không cần máy chủ + +## Chỉ mục (Indexes) + +Chỉ mục tăng tốc các hoạt động truy xuất dữ liệu: +- Tương tự như chỉ mục sách +- Cải thiện hiệu suất truy vấn nhưng tạo thêm chi phí cho các hoạt động ghi +- Các loại bao gồm chỉ mục B-tree, hash, và bitmap + +## Joins (Kết hợp) + +Joins kết hợp các bản ghi từ hai hoặc nhiều bảng: +- **INNER JOIN**: Trả về các bản ghi có giá trị khớp trong cả hai bảng +- **LEFT JOIN**: Trả về tất cả bản ghi từ bảng bên trái và các bản ghi khớp từ bảng bên phải +- **RIGHT JOIN**: Trả về tất cả bản ghi từ bảng bên phải và các bản ghi khớp từ bảng bên trái +- **FULL JOIN**: Trả về tất cả bản ghi khi có sự khớp trong một trong hai bảng + +```sql +SELECT customers.name, orders.order_date +FROM customers +INNER JOIN orders ON customers.customer_id = orders.customer_id; +``` + +## Khi nào sử dụng cơ sở dữ liệu quan hệ + +Cơ sở dữ liệu quan hệ lý tưởng cho: +- Dữ liệu có cấu trúc với mối quan hệ rõ ràng +- Ứng dụng yêu cầu truy vấn phức tạp và giao dịch +- Hệ thống mà tính toàn vẹn dữ liệu là rất quan trọng +- Các tình huống mà tính nhất quán quan trọng hơn tốc độ + +## Tài liệu tham khảo + +- Codd, E.F. (1970). "A Relational Model of Data for Large Shared Data Banks" +- Date, C.J. "An Introduction to Database Systems" +- Garcia-Molina, H., Ullman, J.D., & Widom, J. "Database Systems: The Complete Book" \ No newline at end of file diff --git a/i18n/vi/design-patterns/factory_vi.md b/i18n/vi/design-patterns/factory_vi.md new file mode 100644 index 0000000..63ec969 --- /dev/null +++ b/i18n/vi/design-patterns/factory_vi.md @@ -0,0 +1,476 @@ +# Mẫu thiết kế Factory + +Mẫu Factory là một mẫu thiết kế tạo đối tượng cung cấp giao diện để tạo đối tượng trong lớp cha, nhưng cho phép các lớp con thay đổi loại đối tượng sẽ được tạo. + +## Mục đích + +- Tạo đối tượng mà không để lộ logic khởi tạo cho client +- Tham chiếu đến các đối tượng mới tạo thông qua một giao diện chung +- Tách biệt việc triển khai đối tượng khỏi việc sử dụng nó + +## Vấn đề + +Khi nào bạn nên sử dụng mẫu Factory? + +- Khi một lớp không thể dự đoán trước loại đối tượng mà nó cần tạo +- Khi một lớp muốn các lớp con của nó chỉ định đối tượng mà nó tạo ra +- Khi bạn muốn tập trung kiến thức về việc lớp nào được tạo + +## Các loại mẫu Factory + +Có một số biến thể của mẫu Factory: + +1. **Simple Factory** - Không phải là một mẫu chính thức, nhưng là một cách đơn giản để tách biệt việc tạo đối tượng +2. **Factory Method** - Định nghĩa một giao diện để tạo đối tượng, nhưng để các lớp con quyết định lớp nào sẽ được khởi tạo +3. **Abstract Factory** - Cung cấp một giao diện để tạo ra các họ đối tượng liên quan hoặc phụ thuộc + +## Cấu trúc + +### Mẫu Factory Method + +![Cấu trúc mẫu Factory Method](https://refactoring.guru/images/patterns/diagrams/factory-method/structure.png) + +### Mẫu Abstract Factory + +![Cấu trúc mẫu Abstract Factory](https://refactoring.guru/images/patterns/diagrams/abstract-factory/structure.png) + +## Triển khai + +### Ví dụ về Simple Factory + +```java +// Giao diện Product +interface Product { + void operation(); +} + +// Các sản phẩm cụ thể +class ConcreteProductA implements Product { + @Override + public void operation() { + System.out.println("Thao tác của ConcreteProductA"); + } +} + +class ConcreteProductB implements Product { + @Override + public void operation() { + System.out.println("Thao tác của ConcreteProductB"); + } +} + +// Simple factory +class SimpleFactory { + public Product createProduct(String type) { + if (type.equals("A")) { + return new ConcreteProductA(); + } else if (type.equals("B")) { + return new ConcreteProductB(); + } + throw new IllegalArgumentException("Loại sản phẩm không hợp lệ: " + type); + } +} + +// Client code +class Client { + public static void main(String[] args) { + SimpleFactory factory = new SimpleFactory(); + + Product productA = factory.createProduct("A"); + productA.operation(); + + Product productB = factory.createProduct("B"); + productB.operation(); + } +} +``` + +### Ví dụ về Factory Method + +```java +// Giao diện Product +interface Product { + void operation(); +} + +// Các sản phẩm cụ thể +class ConcreteProductA implements Product { + @Override + public void operation() { + System.out.println("Thao tác của ConcreteProductA"); + } +} + +class ConcreteProductB implements Product { + @Override + public void operation() { + System.out.println("Thao tác của ConcreteProductB"); + } +} + +// Lớp trừu tượng Creator với factory method +abstract class Creator { + public abstract Product createProduct(); + + // Creator cũng có thể bao gồm một số logic nghiệp vụ + public void someOperation() { + // Gọi factory method để tạo một đối tượng Product + Product product = createProduct(); + // Sử dụng sản phẩm + product.operation(); + } +} + +// Các creator cụ thể ghi đè factory method +class ConcreteCreatorA extends Creator { + @Override + public Product createProduct() { + return new ConcreteProductA(); + } +} + +class ConcreteCreatorB extends Creator { + @Override + public Product createProduct() { + return new ConcreteProductB(); + } +} + +// Client code +class Client { + public static void main(String[] args) { + Creator creatorA = new ConcreteCreatorA(); + creatorA.someOperation(); + + Creator creatorB = new ConcreteCreatorB(); + creatorB.someOperation(); + } +} +``` + +### Ví dụ về Abstract Factory + +```java +// Các sản phẩm trừu tượng +interface ProductA { + void operationA(); +} + +interface ProductB { + void operationB(); +} + +// Các sản phẩm cụ thể cho họ 1 +class ConcreteProductA1 implements ProductA { + @Override + public void operationA() { + System.out.println("Thao tác của sản phẩm A1"); + } +} + +class ConcreteProductB1 implements ProductB { + @Override + public void operationB() { + System.out.println("Thao tác của sản phẩm B1"); + } +} + +// Các sản phẩm cụ thể cho họ 2 +class ConcreteProductA2 implements ProductA { + @Override + public void operationA() { + System.out.println("Thao tác của sản phẩm A2"); + } +} + +class ConcreteProductB2 implements ProductB { + @Override + public void operationB() { + System.out.println("Thao tác của sản phẩm B2"); + } +} + +// Giao diện Abstract factory +interface AbstractFactory { + ProductA createProductA(); + ProductB createProductB(); +} + +// Các factory cụ thể +class ConcreteFactory1 implements AbstractFactory { + @Override + public ProductA createProductA() { + return new ConcreteProductA1(); + } + + @Override + public ProductB createProductB() { + return new ConcreteProductB1(); + } +} + +class ConcreteFactory2 implements AbstractFactory { + @Override + public ProductA createProductA() { + return new ConcreteProductA2(); + } + + @Override + public ProductB createProductB() { + return new ConcreteProductB2(); + } +} + +// Client code +class Client { + private ProductA productA; + private ProductB productB; + + public Client(AbstractFactory factory) { + productA = factory.createProductA(); + productB = factory.createProductB(); + } + + public void executeOperations() { + productA.operationA(); + productB.operationB(); + } +} +``` + +## Ví dụ trong các ngôn ngữ khác nhau + +### JavaScript + +```javascript +// Factory Method trong JavaScript + +// Giao diện Product ngầm định trong JavaScript +class Dog { + speak() { + return "Gâu gâu!"; + } +} + +class Cat { + speak() { + return "Meo meo!"; + } +} + +// Creator +class AnimalFactory { + // Factory method + createAnimal(type) { + switch(type) { + case 'dog': + return new Dog(); + case 'cat': + return new Cat(); + default: + throw new Error(`Loại động vật ${type} không được hỗ trợ.`); + } + } +} + +// Sử dụng +const factory = new AnimalFactory(); +const dog = factory.createAnimal('dog'); +const cat = factory.createAnimal('cat'); + +console.log(dog.speak()); // Đầu ra: Gâu gâu! +console.log(cat.speak()); // Đầu ra: Meo meo! +``` + +### Python + +```python +from abc import ABC, abstractmethod + +# Abstract Product +class Button(ABC): + @abstractmethod + def render(self): + pass + + @abstractmethod + def on_click(self): + pass + +# Concrete Products +class HTMLButton(Button): + def render(self): + return "" + + def on_click(self): + return "Nút HTML đã được nhấp!" + +class WindowsButton(Button): + def render(self): + return "Nút Windows" + + def on_click(self): + return "Nút Windows đã được nhấp!" + +# Abstract Creator +class Dialog(ABC): + @abstractmethod + def create_button(self) -> Button: + pass + + def render(self): + # Gọi factory method để tạo đối tượng button + button = self.create_button() + # Bây giờ sử dụng sản phẩm + return f"Dialog hiển thị với {button.render()}" + +# Concrete Creators +class HTMLDialog(Dialog): + def create_button(self) -> Button: + return HTMLButton() + +class WindowsDialog(Dialog): + def create_button(self) -> Button: + return WindowsButton() + +# Client code +def client_code(dialog: Dialog): + print(dialog.render()) + +# Dựa vào môi trường, chúng ta chọn dialog phù hợp +import sys +if sys.platform.startswith('win'): + dialog = WindowsDialog() +else: + dialog = HTMLDialog() + +client_code(dialog) +``` + +### C# + +```csharp +using System; + +// Abstract Product +public interface IVehicle +{ + void Drive(); +} + +// Concrete Products +public class Car : IVehicle +{ + public void Drive() + { + Console.WriteLine("Đang lái xe ô tô..."); + } +} + +public class Motorcycle : IVehicle +{ + public void Drive() + { + Console.WriteLine("Đang lái xe máy..."); + } +} + +// Abstract Creator +public abstract class VehicleFactory +{ + // Factory Method + public abstract IVehicle CreateVehicle(); + + public void DeliverVehicle() + { + IVehicle vehicle = CreateVehicle(); + Console.WriteLine("Đang giao phương tiện..."); + vehicle.Drive(); + } +} + +// Concrete Creators +public class CarFactory : VehicleFactory +{ + public override IVehicle CreateVehicle() + { + return new Car(); + } +} + +public class MotorcycleFactory : VehicleFactory +{ + public override IVehicle CreateVehicle() + { + return new Motorcycle(); + } +} + +// Client code +public class Program +{ + public static void Main() + { + VehicleFactory factory = GetFactory("car"); + factory.DeliverVehicle(); + + factory = GetFactory("motorcycle"); + factory.DeliverVehicle(); + } + + private static VehicleFactory GetFactory(string vehicleType) + { + switch (vehicleType.ToLower()) + { + case "car": + return new CarFactory(); + case "motorcycle": + return new MotorcycleFactory(); + default: + throw new ArgumentException($"Loại phương tiện {vehicleType} không được hỗ trợ."); + } + } +} +``` + +## Trường hợp sử dụng + +- **Tạo thành phần UI**: Tạo các thành phần UI khác nhau dựa trên tùy chọn của người dùng hoặc nền tảng +- **Kết nối cơ sở dữ liệu**: Tạo kết nối cơ sở dữ liệu phù hợp dựa trên cấu hình +- **Tạo tài liệu**: Tạo các loại tài liệu khác nhau (PDF, Word, v.v.) +- **Sản xuất phương tiện**: Tạo các loại phương tiện khác nhau trong một mô phỏng +- **Xử lý thanh toán**: Tạo các phương thức thanh toán khác nhau trong ứng dụng thương mại điện tử + +## Ưu và nhược điểm + +### Ưu điểm + +- Tránh sự kết hợp chặt chẽ giữa creator và các sản phẩm cụ thể +- Nguyên tắc trách nhiệm đơn lẻ: Di chuyển mã tạo sản phẩm đến một nơi +- Nguyên tắc mở/đóng: Các sản phẩm mới có thể được thêm vào mà không phá vỡ mã hiện có +- Tạo đối tượng theo yêu cầu, thay vì tại thời điểm khởi tạo + +### Nhược điểm + +- Mã có thể trở nên phức tạp hơn do việc giới thiệu nhiều lớp con mới +- Client có thể bị giới hạn về các sản phẩm được hiển thị bởi giao diện factory + +## Mối quan hệ với các mẫu khác + +- Các lớp **Abstract Factory** thường được triển khai với Factory Methods +- **Factory Methods** thường được sử dụng trong Template Methods +- **Prototype** có thể là một giải pháp thay thế cho Factory khi mục tiêu là giảm việc tạo lớp con +- **Builder** tập trung vào việc xây dựng các đối tượng phức tạp từng bước một, trong khi Factory Method là một lệnh gọi duy nhất + +## Ví dụ thực tế + +- `Calendar.getInstance()` trong Java +- Các factory widget trong các framework UI +- Các factory kết nối cơ sở dữ liệu +- Các trình tạo tài liệu trong bộ ứng dụng văn phòng + +## Tài liệu tham khảo + +- "Design Patterns: Elements of Reusable Object-Oriented Software" của Gang of Four (GoF) +- [Refactoring Guru - Mẫu Factory Method](https://refactoring.guru/design-patterns/factory-method) +- [Refactoring Guru - Mẫu Abstract Factory](https://refactoring.guru/design-patterns/abstract-factory) \ No newline at end of file diff --git a/i18n/vi/design-patterns/observer_vi.md b/i18n/vi/design-patterns/observer_vi.md new file mode 100644 index 0000000..69155cc --- /dev/null +++ b/i18n/vi/design-patterns/observer_vi.md @@ -0,0 +1,404 @@ +# Mẫu thiết kế Observer + +Mẫu Observer là một mẫu thiết kế hành vi trong đó một đối tượng, gọi là chủ thể (subject), duy trì danh sách các phụ thuộc của nó, gọi là Observer, và thông báo cho họ tự động về bất kỳ thay đổi trạng thái nào, thường bằng cách gọi một trong các phương thức của họ. + +## Mục đích + +- Định nghĩa một mối quan hệ một-nhiều giữa các đối tượng để khi một đối tượng thay đổi trạng thái, tất cả các đối tượng phụ thuộc của nó được thông báo và cập nhật tự động. +- Đóng gói các thành phần cốt lõi trong một lớp Subject trừu tượng, và các thành phần biến đổi trong một phân cấp Observer. +- Các lớp Subject và Observer có thể thay đổi độc lập với nhau. + +## Vấn đề + +Trong nhiều ứng dụng, một số loại đối tượng cụ thể cần được thông báo về những thay đổi trong các đối tượng khác. Tuy nhiên, chúng ta không muốn kết nối quá chặt chẽ các loại đối tượng khác nhau này để duy trì tính linh hoạt và khả năng tái sử dụng. + +Bạn cần một cách để một đối tượng thông báo cho một số lượng không xác định trước các đối tượng khác về những thay đổi, mà không cần các đối tượng đó kết nối chặt chẽ với nhau. + +## Cấu trúc + +![Cấu trúc mẫu Observer](https://refactoring.guru/images/patterns/diagrams/observer/structure.png) + +- **Subject (Chủ thể)**: Giao diện hoặc lớp trừu tượng định nghĩa các hoạt động để gắn, tách, và thông báo cho Observer. +- **ConcreteSubject (Chủ thể cụ thể)**: Duy trì trạng thái mà Observer quan tâm và gửi thông báo khi trạng thái thay đổi. +- **Observer (Observer)**: Giao diện hoặc lớp trừu tượng với phương thức cập nhật được gọi khi trạng thái của chủ thể thay đổi. +- **ConcreteObserver (Observer cụ thể)**: Triển khai giao diện Observer để giữ trạng thái của nó nhất quán với trạng thái của chủ thể. + +## Triển khai + +### Triển khai cơ bản + +```java +// Giao diện Observer +interface Observer { + void update(Subject subject); +} + +// Giao diện Subject +interface Subject { + void attach(Observer observer); + void detach(Observer observer); + void notifyObservers(); +} + +// ConcreteSubject +class ConcreteSubject implements Subject { + private List observers = new ArrayList<>(); + private int state; + + public int getState() { + return state; + } + + public void setState(int state) { + this.state = state; + notifyObservers(); + } + + @Override + public void attach(Observer observer) { + observers.add(observer); + } + + @Override + public void detach(Observer observer) { + observers.remove(observer); + } + + @Override + public void notifyObservers() { + for (Observer observer : observers) { + observer.update(this); + } + } +} + +// ConcreteObserver +class ConcreteObserver implements Observer { + private int observerState; + + @Override + public void update(Subject subject) { + if (subject instanceof ConcreteSubject) { + observerState = ((ConcreteSubject) subject).getState(); + System.out.println("Trạng thái Observer được cập nhật thành: " + observerState); + } + } +} +``` + +### Mô hình Push và Pull + +#### Mô hình Push + +Trong mô hình push, Chủ thể gửi thông tin chi tiết về thay đổi đến tất cả Observer, bất kể họ có cần hay không: + +```java +// Trong ConcreteSubject +public void notifyObservers(int state) { + for (Observer observer : observers) { + observer.update(state); + } +} + +// Trong giao diện Observer +void update(int state); +``` + +#### Mô hình Pull + +Trong mô hình pull, Chủ thể chỉ đơn giản thông báo cho Observer rằng có thay đổi xảy ra, và Observer chịu trách nhiệm lấy dữ liệu cần thiết: + +```java +// Trong ConcreteSubject +public void notifyObservers() { + for (Observer observer : observers) { + observer.update(this); + } +} + +// Trong giao diện Observer +void update(Subject subject); +``` + +## Ví dụ trong các ngôn ngữ khác nhau + +### JavaScript + +```javascript +// Sử dụng lớp ES6 +class Subject { + constructor() { + this.observers = []; + } + + attach(observer) { + if (!this.observers.includes(observer)) { + this.observers.push(observer); + } + } + + detach(observer) { + const index = this.observers.indexOf(observer); + if (index !== -1) { + this.observers.splice(index, 1); + } + } + + notify() { + for (const observer of this.observers) { + observer.update(this); + } + } +} + +class WeatherStation extends Subject { + constructor() { + super(); + this.temperature = 0; + this.humidity = 0; + } + + setMeasurements(temperature, humidity) { + this.temperature = temperature; + this.humidity = humidity; + this.notify(); + } + + getTemperature() { + return this.temperature; + } + + getHumidity() { + return this.humidity; + } +} + +class Observer { + update(subject) {} +} + +class DisplayDevice extends Observer { + constructor(name) { + super(); + this.name = name; + } + + update(weatherStation) { + console.log(`Màn hình ${this.name}: Nhiệt độ ${weatherStation.getTemperature()}°C, Độ ẩm ${weatherStation.getHumidity()}%`); + } +} + +// Cách sử dụng +const weatherStation = new WeatherStation(); +const phoneDisplay = new DisplayDevice('Điện thoại'); +const laptopDisplay = new DisplayDevice('Laptop'); + +weatherStation.attach(phoneDisplay); +weatherStation.attach(laptopDisplay); + +weatherStation.setMeasurements(25, 60); // Cả hai màn hình cập nhật +weatherStation.detach(laptopDisplay); +weatherStation.setMeasurements(26, 70); // Chỉ màn hình điện thoại cập nhật +``` + +### Python + +```python +from abc import ABC, abstractmethod + +# Giao diện Observer +class Observer(ABC): + @abstractmethod + def update(self, subject): + pass + +# Giao diện Subject +class Subject(ABC): + @abstractmethod + def attach(self, observer): + pass + + @abstractmethod + def detach(self, observer): + pass + + @abstractmethod + def notify(self): + pass + +# ConcreteSubject +class NewsPublisher(Subject): + def __init__(self): + self._observers = [] + self._latest_news = None + + def attach(self, observer): + self._observers.append(observer) + + def detach(self, observer): + self._observers.remove(observer) + + def notify(self): + for observer in self._observers: + observer.update(self) + + def add_news(self, news): + self._latest_news = news + self.notify() + + @property + def latest_news(self): + return self._latest_news + +# ConcreteObserver +class NewsSubscriber(Observer): + def __init__(self, name): + self._name = name + + def update(self, subject): + print(f"{self._name} nhận được tin tức: {subject.latest_news}") + +# Cách sử dụng +if __name__ == "__main__": + publisher = NewsPublisher() + + subscriber1 = NewsSubscriber("Người đăng ký 1") + subscriber2 = NewsSubscriber("Người đăng ký 2") + + publisher.attach(subscriber1) + publisher.attach(subscriber2) + + publisher.add_news("Tin nóng: Mẫu Observer đang hoạt động!") + + publisher.detach(subscriber1) + + publisher.add_news("Cập nhật mới: Người đăng ký 1 đã hủy đăng ký!") +``` + +### C# + +```csharp +using System; +using System.Collections.Generic; + +// Giao diện Observer +public interface IObserver +{ + void Update(ISubject subject); +} + +// Giao diện Subject +public interface ISubject +{ + void Attach(IObserver observer); + void Detach(IObserver observer); + void Notify(); +} + +// ConcreteSubject +public class StockMarket : ISubject +{ + private List _observers = new List(); + private Dictionary _stocks = new Dictionary(); + + public void Attach(IObserver observer) + { + Console.WriteLine("Thị trường chứng khoán: Đã gắn một Observer."); + _observers.Add(observer); + } + + public void Detach(IObserver observer) + { + _observers.Remove(observer); + Console.WriteLine("Thị trường chứng khoán: Đã tách một Observer."); + } + + public void Notify() + { + Console.WriteLine("Thị trường chứng khoán: Đang thông báo cho Observer..."); + + foreach (var observer in _observers) + { + observer.Update(this); + } + } + + public void UpdateStockPrice(string stockSymbol, double price) + { + Console.WriteLine($"Thị trường chứng khoán: Giá {stockSymbol} cập nhật thành {price}"); + _stocks[stockSymbol] = price; + Notify(); + } + + public Dictionary GetStocks() + { + return _stocks; + } +} + +// ConcreteObserver +public class Investor : IObserver +{ + private string _name; + private Dictionary _watchlist = new Dictionary(); + + public Investor(string name) + { + _name = name; + } + + public void Update(ISubject subject) + { + if (subject is StockMarket stockMarket) + { + var stocks = stockMarket.GetStocks(); + foreach (var stock in stocks) + { + if (_watchlist.ContainsKey(stock.Key) && _watchlist[stock.Key] != stock.Value) + { + Console.WriteLine($"{_name}: Nhận thấy giá {stock.Key} thay đổi từ {_watchlist[stock.Key]} thành {stock.Value}"); + } + _watchlist[stock.Key] = stock.Value; + } + } + } +} +``` + +## Trường hợp sử dụng thực tế + +1. **Hệ thống xử lý sự kiện**: Các framework UI sử dụng mẫu Observer để xử lý hành động của người dùng. +2. **Dịch vụ đăng ký tin tức**: Người dùng đăng ký các chủ đề và nhận cập nhật. +3. **Theo dõi thị trường chứng khoán**: Nhà đầu tư theo dõi thay đổi giá cổ phiếu. +4. **Thông báo mạng xã hội**: Người dùng nhận thông báo về các hoạt động liên quan đến tài khoản của họ. +5. **Hệ thống hàng đợi tin nhắn**: Nhà xuất bản gửi tin nhắn đến người tiêu dùng đã đăng ký. +6. **Hệ thống giám sát**: Ứng dụng giám sát tài nguyên hệ thống hoặc dịch vụ. + +## Ưu và nhược điểm + +### Ưu điểm + +- **Nguyên tắc Mở/Đóng**: Bạn có thể giới thiệu các lớp người đăng ký mới mà không cần thay đổi mã của nhà xuất bản. +- **Liên kết lỏng lẻo**: Nhà xuất bản không cần biết bất cứ điều gì về người đăng ký. +- **Mối quan hệ động**: Mối quan hệ giữa nhà xuất bản và người đăng ký có thể được thiết lập trong thời gian chạy. +- **Xử lý sự kiện**: Hiệu quả cho việc triển khai hệ thống xử lý sự kiện. + +### Nhược điểm + +- **Cập nhật không mong đợi**: Người đăng ký có thể được thông báo theo thứ tự không thể dự đoán. +- **Rò rỉ bộ nhớ**: Nếu Observer quên hủy đăng ký, họ có thể không được thu gom rác. +- **Chi phí hiệu suất**: Thông báo có thể tốn kém nếu có nhiều Observer hoặc thay đổi trạng thái thường xuyên. +- **Độ phức tạp**: Gỡ lỗi có thể gặp thách thức vì luồng điều khiển ít rõ ràng hơn. + +## Mối quan hệ với các mẫu khác + +- **Mediator (Người trung gian)**: Trong khi Observer phân phối giao tiếp bằng cách giới thiệu đối tượng người đăng ký và nhà xuất bản, Mediator đóng gói giao tiếp giữa các đối tượng. +- **Command (Lệnh)**: Commands có thể được sử dụng để triển khai mẫu Observer bằng cách chuyển yêu cầu thành đối tượng. +- **Memento (Bản ghi nhớ)**: Có thể được sử dụng với Observer để hoàn tác các hoạt động sau khi thông báo cho Observer về các thay đổi. +- **Mẫu MVC**: Mẫu Observer thường được sử dụng trong kiến trúc MVC nơi View quan sát các thay đổi trong Model. + +## Tài liệu tham khảo + +- "Design Patterns: Elements of Reusable Object-Oriented Software" của Gang of Four (GoF) +- [Refactoring Guru - Observer Pattern](https://refactoring.guru/design-patterns/observer) +- [SourceMaking - Observer Pattern](https://sourcemaking.com/design_patterns/observer) \ No newline at end of file diff --git a/i18n/vi/design-patterns/singleton_vi.md b/i18n/vi/design-patterns/singleton_vi.md new file mode 100644 index 0000000..27dd4c8 --- /dev/null +++ b/i18n/vi/design-patterns/singleton_vi.md @@ -0,0 +1,226 @@ +# Mẫu thiết kế Singleton + +Singleton là một mẫu thiết kế tạo đối tượng đảm bảo rằng một lớp chỉ có một thể hiện duy nhất và cung cấp một điểm truy cập toàn cục đến thể hiện đó. + +## Mục đích + +- Đảm bảo một lớp chỉ có một thể hiện duy nhất. +- Cung cấp một điểm truy cập toàn cục đến thể hiện đó. +- Kiểm soát truy cập đồng thời đến tài nguyên được chia sẻ. + +## Vấn đề + +Khi nào bạn nên sử dụng mẫu Singleton? + +- Khi bạn cần chính xác một thể hiện của lớp để điều phối các hành động trong hệ thống +- Khi bạn muốn hạn chế việc khởi tạo của một lớp thành chỉ một đối tượng +- Khi bạn cần kiểm soát chặt chẽ hơn đối với biến toàn cục + +## Cấu trúc + +``` ++----------------+ +| Singleton | ++----------------+ +| -instance | ++----------------+ +| +getInstance() | +| -constructor() | ++----------------+ +``` + +![Cấu trúc mẫu Singleton](https://refactoring.guru/images/patterns/diagrams/singleton/structure-en.png) + +## Triển khai + +### Triển khai cơ bản + +```java +public class Singleton { + // Thể hiện tĩnh riêng tư của lớp + private static Singleton instance; + + // Constructor riêng tư ngăn việc khởi tạo từ các lớp khác + private Singleton() { } + + // Phương thức tĩnh công khai để lấy thể hiện + public static Singleton getInstance() { + if (instance == null) { + instance = new Singleton(); + } + return instance; + } + + // Các phương thức và trường khác + public void doSomething() { + System.out.println("Singleton đang thực hiện một việc gì đó"); + } +} +``` + +### Triển khai an toàn với đa luồng + +```java +public class ThreadSafeSingleton { + private static volatile ThreadSafeSingleton instance; + + private ThreadSafeSingleton() { } + + public static ThreadSafeSingleton getInstance() { + // Kiểm tra khóa hai lần (Double-checked locking) + if (instance == null) { + synchronized (ThreadSafeSingleton.class) { + if (instance == null) { + instance = new ThreadSafeSingleton(); + } + } + } + return instance; + } +} +``` + +### Khởi tạo sớm + +```java +public class EagerSingleton { + // Thể hiện được tạo tại thời điểm tải + private static final EagerSingleton INSTANCE = new EagerSingleton(); + + private EagerSingleton() { } + + public static EagerSingleton getInstance() { + return INSTANCE; + } +} +``` + +### Sử dụng Enum (Java) + +```java +public enum EnumSingleton { + INSTANCE; + + public void doSomething() { + System.out.println("Singleton enum đang thực hiện một việc gì đó"); + } +} +``` + +## Ví dụ trong các ngôn ngữ khác nhau + +### JavaScript + +```javascript +class Singleton { + constructor() { + if (Singleton.instance) { + return Singleton.instance; + } + + // Khởi tạo singleton + this.data = []; + Singleton.instance = this; + } + + add(item) { + this.data.push(item); + } + + get(index) { + return this.data[index]; + } +} + +// Sử dụng +const instance1 = new Singleton(); +const instance2 = new Singleton(); +console.log(instance1 === instance2); // true +``` + +### Python + +```python +class Singleton: + _instance = None + + def __new__(cls): + if cls._instance is None: + cls._instance = super(Singleton, cls).__new__(cls) + # Khởi tạo singleton của bạn tại đây + cls._instance.value = 0 + return cls._instance + +# Sử dụng +s1 = Singleton() +s2 = Singleton() +print(s1 is s2) # True +``` + +### C# + +```csharp +public sealed class Singleton +{ + private static Singleton instance = null; + private static readonly object padlock = new object(); + + Singleton() {} + + public static Singleton Instance + { + get + { + lock(padlock) + { + if (instance == null) + { + instance = new Singleton(); + } + return instance; + } + } + } +} +``` + +## Trường hợp sử dụng + +- **Kết nối cơ sở dữ liệu**: Quản lý một pool kết nối +- **Logger**: Tạo một thể hiện ghi log duy nhất cho ứng dụng +- **Cài đặt cấu hình**: Lưu trữ cài đặt ứng dụng +- **Cache**: Tạo một trình quản lý cache duy nhất +- **Thread pools**: Quản lý việc tạo và gán thread + +## Ưu và nhược điểm + +### Ưu điểm + +- Đảm bảo một lớp chỉ có một thể hiện duy nhất +- Cung cấp một điểm truy cập toàn cục đến thể hiện đó +- Đối tượng singleton chỉ được khởi tạo khi nó được yêu cầu lần đầu tiên + +### Nhược điểm + +- Vi phạm Nguyên lý trách nhiệm đơn lẻ (lớp quản lý việc tạo ra chính nó) +- Có thể che giấu thiết kế không tốt, ví dụ, khi các thành phần biết quá nhiều về nhau +- Yêu cầu xử lý đặc biệt trong môi trường đa luồng +- Làm cho việc kiểm thử đơn vị khó khăn hơn + +## Mối quan hệ với các mẫu khác + +- Một **Facade** có thể trông giống như một Singleton nếu nó chỉ ẩn một đối tượng, nhưng chúng có mục đích khác nhau +- **Abstract Factories**, **Builders**, và **Prototypes** đều có thể được triển khai như Singletons + +## Ví dụ thực tế + +- Lớp `java.lang.Runtime` trong Java +- Các trình quản lý UI trong nhiều framework GUI +- Windows Registry +- Đối tượng window trong trình duyệt + +## Tài liệu tham khảo + +- "Design Patterns: Elements of Reusable Object-Oriented Software" của Gang of Four (GoF) +- [Refactoring Guru - Singleton Pattern](https://refactoring.guru/design-patterns/singleton) +- [SourceMaking - Singleton Pattern](https://sourcemaking.com/design_patterns/singleton) \ No newline at end of file diff --git a/i18n/vi/devops/ci-cd_vi.md b/i18n/vi/devops/ci-cd_vi.md new file mode 100644 index 0000000..8b9dd04 --- /dev/null +++ b/i18n/vi/devops/ci-cd_vi.md @@ -0,0 +1,162 @@ +# Tích Hợp Liên Tục và Triển Khai Liên Tục (CI/CD) + +Tích hợp liên tục và triển khai liên tục (CI/CD) là một phương pháp để thường xuyên cung cấp ứng dụng cho khách hàng bằng cách đưa tự động hóa vào các giai đoạn phát triển ứng dụng. + +## CI/CD là gì? + +### Tích Hợp Liên Tục (CI) +Tích hợp liên tục là một phương pháp phát triển trong đó các nhà phát triển tích hợp mã vào kho lưu trữ chung thường xuyên, tốt nhất là nhiều lần mỗi ngày. Mỗi lần tích hợp sau đó được xác minh bằng một bản dựng tự động và các bài kiểm tra tự động. + +### Phân Phối Liên Tục (CD) +Phân phối liên tục là một phần mở rộng của tích hợp liên tục để đảm bảo rằng bạn có thể phát hành các thay đổi mới cho khách hàng một cách nhanh chóng và bền vững. Điều này có nghĩa là ngoài việc tự động hóa kiểm tra, bạn cũng đã tự động hóa quy trình phát hành và bạn có thể triển khai ứng dụng của mình bất kỳ lúc nào bằng cách nhấn nút. + +### Triển Khai Liên Tục +Triển khai liên tục tiến xa hơn một bước so với phân phối liên tục. Với phương pháp này, mọi thay đổi vượt qua tất cả các giai đoạn của đường ống sản xuất của bạn đều được phát hành cho khách hàng của bạn. Không có sự can thiệp của con người, và chỉ có một bài kiểm tra thất bại mới ngăn chặn một thay đổi mới được triển khai lên môi trường sản xuất. + +## Các Thành Phần của Đường Ống CI/CD + +Một đường ống CI/CD điển hình bao gồm các giai đoạn sau: + +1. **Nguồn**: Mã được commit vào hệ thống quản lý phiên bản (Git, SVN, v.v.) +2. **Xây Dựng**: Mã được biên dịch, các phụ thuộc được giải quyết +3. **Kiểm Tra**: Các bài kiểm tra tự động được chạy (kiểm tra đơn vị, kiểm tra tích hợp, v.v.) +4. **Triển Khai**: Ứng dụng được triển khai lên môi trường dàn dựng/sản xuất +5. **Giám Sát**: Hiệu suất ứng dụng và lỗi được giám sát + +## Các Công Cụ CI/CD Phổ Biến + +### Jenkins + +Jenkins là một máy chủ tự động hóa mã nguồn mở cho phép các nhà phát triển xây dựng, kiểm tra và triển khai phần mềm của họ. + +```yaml +# Ví dụ Jenkinsfile +pipeline { + agent any + + stages { + stage('Xây Dựng') { + steps { + echo 'Đang xây dựng..' + sh 'npm install' + } + } + stage('Kiểm Tra') { + steps { + echo 'Đang kiểm tra..' + sh 'npm test' + } + } + stage('Triển Khai') { + steps { + echo 'Đang triển khai....' + sh 'npm run deploy' + } + } + } +} +``` + +### GitHub Actions + +GitHub Actions là một nền tảng CI/CD cho phép bạn tự động hóa quy trình xây dựng, kiểm tra và triển khai trực tiếp từ GitHub. + +```yaml +# Ví dụ quy trình làm việc GitHub Actions +name: Node.js CI + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Sử dụng Node.js + uses: actions/setup-node@v1 + with: + node-version: '14.x' + - name: Cài đặt phụ thuộc + run: npm ci + - name: Chạy kiểm tra + run: npm test + - name: Triển khai + if: github.ref == 'refs/heads/main' + run: npm run deploy +``` + +### GitLab CI/CD + +GitLab CI/CD là một phần của GitLab cho phép bạn áp dụng tất cả các phương pháp liên tục (Tích hợp, Phân phối và Triển khai liên tục) vào phần mềm của bạn. + +```yaml +# Ví dụ .gitlab-ci.yml +stages: + - build + - test + - deploy + +build: + stage: build + script: + - echo "Đang xây dựng ứng dụng" + - npm install + +test: + stage: test + script: + - echo "Đang chạy kiểm tra" + - npm test + +deploy: + stage: deploy + script: + - echo "Đang triển khai ứng dụng" + - npm run deploy + only: + - main +``` + +### CircleCI + +CircleCI là một công cụ CI/CD dựa trên đám mây tự động hóa quy trình phát triển phần mềm. + +```yaml +# Ví dụ cấu hình CircleCI +version: 2.1 +jobs: + build: + docker: + - image: cimg/node:14.17 + steps: + - checkout + - run: npm install + - run: npm test + - run: npm run deploy +``` + +## Các Phương Pháp Tốt Nhất cho CI/CD + +1. **Tự Động Hóa Mọi Thứ**: Tự động hóa càng nhiều quy trình phân phối phần mềm càng tốt. +2. **Thất Bại Nhanh Chóng**: Phát hiện và giải quyết vấn đề càng sớm càng tốt trong quy trình phát triển. +3. **Giữ Bản Dựng Xanh**: Một bản dựng bị hỏng nên là ưu tiên cao nhất của nhóm để sửa chữa. +4. **Xây Dựng Chỉ Một Lần**: Xây dựng các tạo phẩm một lần và thăng cấp cùng một tạo phẩm qua đường ống. +5. **Triển Khai Theo Cùng Một Cách cho Mọi Môi Trường**: Sử dụng cùng một quy trình triển khai cho tất cả các môi trường. +6. **Kiểm Tra Khói cho Các Triển Khai**: Chạy các bài kiểm tra cơ bản sau khi triển khai để xác minh hệ thống đang chạy đúng. +7. **Giữ Đường Ống CI/CD Nhanh**: Hướng tới một đường ống hoàn thành trong vòng chưa đến 10 phút. +8. **Duy Trì Độ Phủ Kiểm Tra Tốt**: Đảm bảo các bài kiểm tra của bạn bao phủ phần lớn mã nguồn của bạn. + +## Tài Liệu Tham Khảo + +- [Martin Fowler về Tích Hợp Liên Tục](https://martinfowler.com/articles/continuousIntegration.html) +- [Sổ Tay DevOps](https://itrevolution.com/book/the-devops-handbook/) +- [Phân Phối Liên Tục](https://continuousdelivery.com/) +- [Tài Liệu Jenkins](https://www.jenkins.io/doc/) +- [Tài Liệu GitHub Actions](https://docs.github.com/en/actions) +- [Tài Liệu GitLab CI/CD](https://docs.gitlab.com/ee/ci/) +- [Tài Liệu CircleCI](https://circleci.com/docs/) diff --git a/i18n/vi/linux/bash-scripting_vi.md b/i18n/vi/linux/bash-scripting_vi.md new file mode 100644 index 0000000..329f3ff --- /dev/null +++ b/i18n/vi/linux/bash-scripting_vi.md @@ -0,0 +1,325 @@ +# Lập Trình Bash + +Bash (Bourne Again SHell) là một ngôn ngữ thông dịch lệnh được sử dụng rộng rãi trên nhiều hệ điều hành, và là shell mặc định trên hầu hết các bản phân phối Linux. + +## Giới Thiệu về Lập Trình Bash + +Các script Bash là các tệp văn bản chứa một chuỗi các lệnh được thực thi bởi shell Bash. Chúng cho phép bạn tự động hóa các tác vụ lặp đi lặp lại, kết hợp các lệnh phức tạp, và tạo các tiện ích tùy chỉnh. + +## Cú Pháp Cơ Bản + +### Tạo một Script Bash + +1. Tạo một tệp với phần mở rộng `.sh` +2. Thêm dòng shebang ở đầu: `#!/bin/bash` +3. Làm cho script có thể thực thi: `chmod +x script.sh` +4. Chạy script: `./script.sh` + +### Ví Dụ Hello World + +```bash +#!/bin/bash +# Đây là một chú thích +echo "Xin chào, Thế giới!" +``` + +## Biến + +### Khai Báo và Sử Dụng Biến + +```bash +#!/bin/bash + +# Khai báo biến +ten="Nguyen" +tuoi=30 + +# Sử dụng biến +echo "Tên: $ten" +echo "Tuổi: $tuoi" + +# Thay thế lệnh +ngay_hien_tai=$(date) +echo "Ngày hiện tại: $ngay_hien_tai" + +# Phép toán +ket_qua=$((10 + 5)) +echo "10 + 5 = $ket_qua" +``` + +### Biến Đặc Biệt + +| Biến | Mô tả | +|----------|-------------| +| `$0` | Tên của script | +| `$1` đến `$9` | 9 tham số đầu tiên được truyền vào script | +| `$#` | Số lượng tham số được truyền vào script | +| `$@` | Tất cả tham số được truyền vào script | +| `$?` | Trạng thái thoát của lệnh cuối cùng | +| `$$` | Process ID của script hiện tại | +| `$USER` | Tên người dùng đang chạy script | +| `$HOSTNAME` | Tên máy chủ | +| `$RANDOM` | Một số ngẫu nhiên | +| `$HOME` | Thư mục home của người dùng | + +## Cấu Trúc Điều Khiển + +### Câu Lệnh Điều Kiện + +#### Câu Lệnh If-Else + +```bash +#!/bin/bash + +tuoi=25 + +if [ $tuoi -lt 18 ]; then + echo "Bạn là trẻ vị thành niên." +elif [ $tuoi -ge 18 ] && [ $tuoi -lt 65 ]; then + echo "Bạn là người trưởng thành." +else + echo "Bạn là người cao tuổi." +fi +``` + +#### Câu Lệnh Case + +```bash +#!/bin/bash + +trai_cay="táo" + +case $trai_cay in + "táo") + echo "Đây là quả táo." + ;; + "chuối") + echo "Đây là quả chuối." + ;; + "cam") + echo "Đây là quả cam." + ;; + *) + echo "Không xác định được loại trái cây." + ;; +esac +``` + +### Vòng Lặp + +#### Vòng Lặp For + +```bash +#!/bin/bash + +# Vòng lặp for đơn giản +for i in 1 2 3 4 5; do + echo "Số: $i" +done + +# Vòng lặp for với khoảng +for i in {1..5}; do + echo "Số: $i" +done + +# Vòng lặp for với bước nhảy +for i in {1..10..2}; do + echo "Số lẻ: $i" +done + +# Vòng lặp for với đầu ra lệnh +for file in $(ls); do + echo "Tệp: $file" +done +``` + +#### Vòng Lặp While + +```bash +#!/bin/bash + +count=1 + +while [ $count -le 5 ]; do + echo "Đếm: $count" + ((count++)) +done +``` + +#### Vòng Lặp Until + +```bash +#!/bin/bash + +count=1 + +until [ $count -gt 5 ]; do + echo "Đếm: $count" + ((count++)) +done +``` + +## Hàm + +### Định Nghĩa và Sử Dụng Hàm + +```bash +#!/bin/bash + +# Định nghĩa hàm +chao_hoi() { + echo "Xin chào, $1!" +} + +# Hàm với giá trị trả về +cong() { + local ket_qua=$(($1 + $2)) + echo $ket_qua +} + +# Gọi hàm +chao_hoi "Nguyễn" +tong=$(cong 5 3) +echo "5 + 3 = $tong" +``` + +## Đầu Vào và Đầu Ra + +### Đọc Đầu Vào Người Dùng + +```bash +#!/bin/bash + +# Đọc một giá trị +echo "Nhập tên của bạn:" +read ten +echo "Xin chào, $ten!" + +# Đọc nhiều giá trị +echo "Nhập họ và tên của bạn:" +read ho ten +echo "Xin chào, $ho $ten!" + +# Đọc với lời nhắc +read -p "Nhập tuổi của bạn: " tuoi +echo "Bạn $tuoi tuổi." + +# Đọc mật khẩu (ẩn đầu vào) +read -sp "Nhập mật khẩu của bạn: " mat_khau +echo -e "\nĐã nhận mật khẩu." +``` + +### Đầu Vào/Đầu Ra Tệp + +```bash +#!/bin/bash + +# Ghi vào tệp +echo "Xin chào, Thế giới!" > output.txt +echo "Đây là một dòng mới." >> output.txt + +# Đọc từ tệp +while IFS= read -r line; do + echo "Dòng: $line" +done < input.txt + +# Xử lý từng dòng của tệp +cat input.txt | while read line; do + echo "Đang xử lý: $line" +done +``` + +## Mảng + +### Thao Tác Mảng + +```bash +#!/bin/bash + +# Khai báo mảng +trai_cay=("táo" "chuối" "cam" "nho") + +# Truy cập phần tử mảng +echo "Trái cây đầu tiên: ${trai_cay[0]}" +echo "Tất cả trái cây: ${trai_cay[@]}" +echo "Số lượng trái cây: ${#trai_cay[@]}" + +# Lặp qua mảng +for trai_cay in "${trai_cay[@]}"; do + echo "Trái cây: $trai_cay" +done + +# Thêm phần tử vào mảng +trai_cay+=("kiwi") + +# Xóa phần tử khỏi mảng +unset trai_cay[1] +``` + +## Thao Tác Chuỗi + +### Thao Tác Chuỗi + +```bash +#!/bin/bash + +# Độ dài chuỗi +str="Xin chào, Thế giới!" +echo "Độ dài: ${#str}" + +# Chuỗi con +echo "Chuỗi con: ${str:7:5}" + +# Thay thế chuỗi +echo "Thay thế: ${str/Thế giới/Bash}" + +# Chuyển đổi sang chữ hoa/chữ thường +echo "Chữ hoa: ${str^^}" +echo "Chữ thường: ${str,,}" +``` + +## Xử Lý Lỗi + +### Xử Lý Lỗi Cơ Bản + +```bash +#!/bin/bash + +# Thoát khi có lỗi +set -e + +# Xử lý lỗi tùy chỉnh +xu_ly_loi() { + echo "Lỗi xảy ra tại dòng $1" + exit 1 +} + +# Bắt lỗi +trap 'xu_ly_loi $LINENO' ERR + +# Kiểm tra thành công của lệnh +if ! command -v git &> /dev/null; then + echo "Git chưa được cài đặt." + exit 1 +fi +``` + +## Các Phương Pháp Tốt Nhất + +1. **Sử Dụng Shebang**: Luôn bao gồm `#!/bin/bash` ở đầu script của bạn. +2. **Chú Thích**: Thêm chú thích để giải thích logic phức tạp. +3. **Xử Lý Lỗi**: Triển khai xử lý lỗi thích hợp. +4. **Thụt Lề**: Sử dụng thụt lề nhất quán để dễ đọc. +5. **Quy Ước Đặt Tên**: Sử dụng tên mô tả cho biến và hàm. +6. **Trích Dẫn Biến**: Luôn trích dẫn biến để xử lý khoảng trắng và ký tự đặc biệt. +7. **Mã Thoát**: Trả về mã thoát thích hợp. +8. **Tính Mô-đun**: Chia các script phức tạp thành các hàm. +9. **Gỡ Lỗi**: Sử dụng `set -x` để gỡ lỗi. +10. **Kiểm Tra**: Kiểm tra script của bạn với các đầu vào khác nhau. + +## Tài Liệu Tham Khảo + +- [Hướng Dẫn Sử Dụng GNU Bash](https://www.gnu.org/software/bash/manual/) +- [Hướng Dẫn Bash cho Người Mới Bắt Đầu](https://tldp.org/LDP/Bash-Beginners-Guide/html/) +- [Hướng Dẫn Lập Trình Bash Nâng Cao](https://tldp.org/LDP/abs/html/) +- [ShellCheck](https://www.shellcheck.net/) - Một công cụ phân tích script shell diff --git a/i18n/vi/system-design/microservices_vi.md b/i18n/vi/system-design/microservices_vi.md new file mode 100644 index 0000000..80da511 --- /dev/null +++ b/i18n/vi/system-design/microservices_vi.md @@ -0,0 +1,467 @@ +# Kiến Trúc Microservices + +Kiến trúc microservices là một phong cách kiến trúc cấu trúc một ứng dụng như một tập hợp các dịch vụ nhỏ, liên kết lỏng lẻo có thể được phát triển, triển khai và mở rộng độc lập. + +## Microservices là gì? + +Microservices là các dịch vụ nhỏ, tự chủ hoạt động cùng nhau để tạo thành một ứng dụng hoàn chỉnh. Mỗi microservice: + +- Tập trung vào một khả năng kinh doanh duy nhất +- Chạy trong quy trình riêng của nó +- Giao tiếp thông qua API được định nghĩa rõ ràng +- Có thể được triển khai độc lập +- Có thể được viết bằng các ngôn ngữ lập trình khác nhau +- Có thể sử dụng các công nghệ lưu trữ dữ liệu khác nhau + +## Kiến Trúc Nguyên Khối vs. Microservices + +| Khía cạnh | Nguyên khối | Microservices | +|--------|------------|---------------| +| Cấu trúc | Codebase thống nhất, đơn lẻ | Nhiều dịch vụ độc lập | +| Phát triển | Đơn giản hơn để phát triển ban đầu | Thiết lập ban đầu phức tạp hơn | +| Triển khai | Triển khai toàn bộ ứng dụng | Triển khai từng dịch vụ riêng biệt | +| Mở rộng | Mở rộng toàn bộ ứng dụng | Mở rộng các dịch vụ riêng lẻ khi cần | +| Công nghệ | Một ngăn xếp công nghệ duy nhất | Có thể sử dụng nhiều ngăn xếp công nghệ | +| Cấu trúc nhóm | Các nhóm lớn hơn làm việc trên cùng một codebase | Các nhóm nhỏ hơn làm việc trên các dịch vụ riêng lẻ | +| Tác động của lỗi | Điểm lỗi duy nhất | Lỗi cô lập | +| Quản lý dữ liệu | Cơ sở dữ liệu được chia sẻ | Cơ sở dữ liệu cho mỗi dịch vụ | + +## Nguyên Tắc Chính của Microservices + +1. **Trách Nhiệm Đơn Lẻ**: Mỗi dịch vụ chịu trách nhiệm cho một khả năng kinh doanh cụ thể. +2. **Tự Chủ**: Các dịch vụ có thể được phát triển, triển khai và mở rộng độc lập. +3. **Khả Năng Phục Hồi**: Lỗi trong một dịch vụ không nên lan truyền sang các dịch vụ khác. +4. **Phân Cấp**: Quản trị và quản lý dữ liệu phi tập trung. +5. **Phân Phối Liên Tục**: Triển khai tự động, thường xuyên của các dịch vụ riêng lẻ. +6. **Khả Năng Quan Sát**: Giám sát và ghi nhật ký toàn diện. +7. **Thiết Kế Hướng Miền**: Các dịch vụ được thiết kế xung quanh các miền kinh doanh. + +## Mẫu Giao Tiếp Microservices + +### Giao Tiếp Đồng Bộ + +#### REST API + +```json +// Ví dụ yêu cầu REST API +GET /api/products/123 +Accept: application/json + +// Ví dụ phản hồi +{ + "id": "123", + "name": "Tên Sản Phẩm", + "price": 19.99, + "category": "Điện tử" +} +``` + +#### gRPC + +```protobuf +// Ví dụ định nghĩa dịch vụ gRPC +syntax = "proto3"; + +service ProductService { + rpc GetProduct(ProductRequest) returns (Product); +} + +message ProductRequest { + string id = 1; +} + +message Product { + string id = 1; + string name = 2; + double price = 3; + string category = 4; +} +``` + +### Giao Tiếp Bất Đồng Bộ + +#### Hàng Đợi Thông Điệp + +```javascript +// Ví dụ nhà sản xuất thông điệp (Node.js với RabbitMQ) +const amqp = require('amqplib'); + +async function sendOrderCreatedEvent(order) { + const connection = await amqp.connect('amqp://localhost'); + const channel = await connection.createChannel(); + + const queue = 'order_events'; + const message = JSON.stringify({ + type: 'ORDER_CREATED', + data: order + }); + + await channel.assertQueue(queue, { durable: true }); + channel.sendToQueue(queue, Buffer.from(message)); + + console.log(`Đã gửi: ${message}`); + + setTimeout(() => { + connection.close(); + }, 500); +} +``` + +```javascript +// Ví dụ người tiêu thụ thông điệp (Node.js với RabbitMQ) +const amqp = require('amqplib'); + +async function processOrderEvents() { + const connection = await amqp.connect('amqp://localhost'); + const channel = await connection.createChannel(); + + const queue = 'order_events'; + + await channel.assertQueue(queue, { durable: true }); + console.log(`Đang đợi thông điệp trong ${queue}`); + + channel.consume(queue, (msg) => { + const event = JSON.parse(msg.content.toString()); + console.log(`Đã nhận: ${event.type}`); + + if (event.type === 'ORDER_CREATED') { + // Xử lý đơn hàng + processOrder(event.data); + } + + channel.ack(msg); + }); +} +``` + +#### Luồng Sự Kiện + +```java +// Ví dụ nhà sản xuất Kafka (Java) +Properties props = new Properties(); +props.put("bootstrap.servers", "localhost:9092"); +props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); +props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); + +Producer producer = new KafkaProducer<>(props); + +String topic = "order-events"; +String key = order.getId(); +String value = objectMapper.writeValueAsString(order); + +ProducerRecord record = new ProducerRecord<>(topic, key, value); +producer.send(record); +producer.close(); +``` + +```java +// Ví dụ người tiêu thụ Kafka (Java) +Properties props = new Properties(); +props.put("bootstrap.servers", "localhost:9092"); +props.put("group.id", "order-processing-group"); +props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); +props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer"); + +Consumer consumer = new KafkaConsumer<>(props); +consumer.subscribe(Arrays.asList("order-events")); + +while (true) { + ConsumerRecords records = consumer.poll(Duration.ofMillis(100)); + for (ConsumerRecord record : records) { + String key = record.key(); + String value = record.value(); + + Order order = objectMapper.readValue(value, Order.class); + processOrder(order); + } +} +``` + +## Khám Phá Dịch Vụ và API Gateway + +### Khám Phá Dịch Vụ + +```yaml +# Ví dụ đăng ký dịch vụ Consul +{ + "service": { + "name": "product-service", + "id": "product-service-1", + "tags": ["api", "v1"], + "address": "10.0.0.1", + "port": 8080, + "checks": [ + { + "http": "http://10.0.0.1:8080/health", + "interval": "10s" + } + ] + } +} +``` + +### API Gateway + +```yaml +# Ví dụ cấu hình Kong API Gateway +services: + - name: product-service + url: http://product-service:8080 + routes: + - name: product-routes + paths: + - /api/products + strip_path: true + plugins: + - name: rate-limiting + config: + minute: 100 + - name: jwt +``` + +## Quản Lý Dữ Liệu trong Microservices + +### Cơ Sở Dữ Liệu cho Mỗi Dịch Vụ + +```yaml +# Ví dụ docker-compose.yml cho nhiều cơ sở dữ liệu +version: '3' +services: + product-service: + build: ./product-service + depends_on: + - product-db + environment: + - DB_HOST=product-db + - DB_PORT=5432 + - DB_NAME=productdb + + product-db: + image: postgres:13 + environment: + - POSTGRES_DB=productdb + - POSTGRES_USER=user + - POSTGRES_PASSWORD=password + volumes: + - product-db-data:/var/lib/postgresql/data + + order-service: + build: ./order-service + depends_on: + - order-db + environment: + - DB_HOST=order-db + - DB_PORT=27017 + - DB_NAME=orderdb + + order-db: + image: mongo:4.4 + environment: + - MONGO_INITDB_DATABASE=orderdb + volumes: + - order-db-data:/data/db + +volumes: + product-db-data: + order-db-data: +``` + +### Mẫu CQRS + +```csharp +// Phía lệnh +public class CreateOrderCommand +{ + public string CustomerId { get; set; } + public List Items { get; set; } +} + +public class OrderCommandHandler +{ + private readonly IOrderRepository _repository; + private readonly IEventBus _eventBus; + + public OrderCommandHandler(IOrderRepository repository, IEventBus eventBus) + { + _repository = repository; + _eventBus = eventBus; + } + + public async Task Handle(CreateOrderCommand command) + { + var order = new Order(Guid.NewGuid(), command.CustomerId, command.Items); + await _repository.SaveAsync(order); + + await _eventBus.PublishAsync(new OrderCreatedEvent + { + OrderId = order.Id, + CustomerId = order.CustomerId, + Items = order.Items + }); + } +} + +// Phía truy vấn +public class OrderQueryService +{ + private readonly IOrderReadModel _readModel; + + public OrderQueryService(IOrderReadModel readModel) + { + _readModel = readModel; + } + + public async Task GetOrderAsync(Guid orderId) + { + return await _readModel.GetOrderAsync(orderId); + } + + public async Task> GetCustomerOrdersAsync(string customerId) + { + return await _readModel.GetCustomerOrdersAsync(customerId); + } +} +``` + +## Triển Khai Microservices + +### Docker Containers + +```dockerfile +# Ví dụ Dockerfile cho một microservice +FROM node:14-alpine + +WORKDIR /app + +COPY package*.json ./ +RUN npm install --production + +COPY . . + +EXPOSE 8080 + +CMD ["node", "server.js"] +``` + +### Kubernetes + +```yaml +# Ví dụ triển khai Kubernetes cho một microservice +apiVersion: apps/v1 +kind: Deployment +metadata: + name: product-service + labels: + app: product-service +spec: + replicas: 3 + selector: + matchLabels: + app: product-service + template: + metadata: + labels: + app: product-service + spec: + containers: + - name: product-service + image: my-registry/product-service:1.0.0 + ports: + - containerPort: 8080 + env: + - name: DB_HOST + value: product-db-service + - name: DB_PORT + value: "5432" + - name: DB_NAME + value: productdb + livenessProbe: + httpGet: + path: /health + port: 8080 + initialDelaySeconds: 30 + periodSeconds: 10 +--- +apiVersion: v1 +kind: Service +metadata: + name: product-service +spec: + selector: + app: product-service + ports: + - port: 80 + targetPort: 8080 + type: ClusterIP +``` + +## Giám Sát và Khả Năng Quan Sát + +### Truy Vết Phân Tán + +```java +// Ví dụ sử dụng Spring Cloud Sleuth và Zipkin +@RestController +public class ProductController { + + private final ProductService productService; + + @Autowired + public ProductController(ProductService productService) { + this.productService = productService; + } + + @GetMapping("/products/{id}") + public Product getProduct(@PathVariable String id) { + // Truy vết được tự động xử lý bởi Sleuth + return productService.getProduct(id); + } +} +``` + +### Thu Thập Số Liệu + +```yaml +# Ví dụ cấu hình Prometheus +global: + scrape_interval: 15s + +scrape_configs: + - job_name: 'product-service' + metrics_path: '/actuator/prometheus' + static_configs: + - targets: ['product-service:8080'] + + - job_name: 'order-service' + metrics_path: '/actuator/prometheus' + static_configs: + - targets: ['order-service:8080'] +``` + +## Thách Thức và Phương Pháp Tốt Nhất + +### Thách Thức + +1. **Độ Phức Tạp của Hệ Thống Phân Tán**: Gỡ lỗi và kiểm tra trở nên khó khăn hơn. +2. **Tính Nhất Quán của Dữ Liệu**: Duy trì tính nhất quán giữa các dịch vụ là một thách thức. +3. **Ranh Giới Dịch Vụ**: Xác định ranh giới dịch vụ đúng đắn đòi hỏi chuyên môn về miền. +4. **Phụ Phí Vận Hành**: Nhiều dịch vụ hơn đồng nghĩa với nhiều cơ sở hạ tầng cần quản lý hơn. +5. **Độ Trễ Mạng**: Giao tiếp giữa các dịch vụ thêm độ trễ. + +### Phương Pháp Tốt Nhất + +1. **Bắt Đầu Nguyên Khối**: Bắt đầu với một ứng dụng nguyên khối và trích xuất microservices khi cần thiết. +2. **Thiết Kế cho Lỗi**: Triển khai các bộ ngắt mạch, thử lại và dự phòng. +3. **Tự Động Hóa Mọi Thứ**: Sử dụng đường ống CI/CD cho tất cả các dịch vụ. +4. **Triển Khai Giám Sát**: Ghi nhật ký, số liệu và truy vết toàn diện. +5. **Sử Dụng Container**: Containerize các dịch vụ để đảm bảo tính nhất quán giữa các môi trường. +6. **Phiên Bản API**: Triển khai phiên bản API thích hợp để quản lý các thay đổi. +7. **Tài Liệu**: Duy trì tài liệu rõ ràng cho tất cả các dịch vụ và API. +8. **Kiểm Tra**: Triển khai các chiến lược kiểm tra toàn diện, bao gồm kiểm tra hợp đồng. + +## Tài Liệu Tham Khảo + +- [Microservices.io](https://microservices.io/) +- [Martin Fowler về Microservices](https://martinfowler.com/articles/microservices.html) +- [Sam Newman - Xây Dựng Microservices](https://samnewman.io/books/building_microservices/) +- [Chris Richardson - Mẫu Microservices](https://microservices.io/book) diff --git a/i18n/vi/testing/unit-testing_vi.md b/i18n/vi/testing/unit-testing_vi.md new file mode 100644 index 0000000..018a504 --- /dev/null +++ b/i18n/vi/testing/unit-testing_vi.md @@ -0,0 +1,467 @@ +# Kiểm Thử Đơn Vị + +Kiểm thử đơn vị là một phương pháp kiểm thử phần mềm trong đó các đơn vị hoặc thành phần riêng lẻ của phần mềm được kiểm tra một cách cô lập với phần còn lại của hệ thống. + +## Kiểm Thử Đơn Vị là gì? + +Một bài kiểm thử đơn vị xác minh rằng một phần mã nhỏ, cô lập (một "đơn vị") hoạt động chính xác như mong đợi của nhà phát triển. Các đơn vị thường là: + +- Các hàm hoặc phương thức riêng lẻ +- Các lớp +- Các mô-đun hoặc thành phần + +Mục tiêu là xác nhận rằng mỗi đơn vị của phần mềm hoạt động như thiết kế. + +## Lợi Ích của Kiểm Thử Đơn Vị + +- **Phát Hiện Lỗi Sớm**: Phát hiện lỗi sớm trong chu trình phát triển +- **Tạo Điều Kiện cho Thay Đổi**: Giúp việc tái cấu trúc mã và thêm tính năng mới dễ dàng hơn +- **Tài Liệu**: Các bài kiểm thử đóng vai trò như tài liệu về cách mã nên hoạt động +- **Cải Thiện Thiết Kế**: Khuyến khích thiết kế phần mềm và tính mô-đun tốt hơn +- **Tự Tin**: Cung cấp sự tự tin rằng mã hoạt động như mong đợi +- **Giảm Chi Phí**: Rẻ hơn để sửa lỗi được phát hiện trong quá trình kiểm thử đơn vị hơn là các giai đoạn sau + +## Nguyên Tắc Kiểm Thử Đơn Vị + +### Nguyên Tắc FIRST + +- **Fast (Nhanh)**: Các bài kiểm thử nên chạy nhanh +- **Independent (Độc lập)**: Các bài kiểm thử không nên phụ thuộc vào nhau +- **Repeatable (Lặp lại được)**: Các bài kiểm thử nên cho kết quả giống nhau mỗi lần chạy +- **Self-validating (Tự xác thực)**: Các bài kiểm thử nên tự động xác định xem chúng đã vượt qua hay thất bại +- **Timely (Kịp thời)**: Các bài kiểm thử nên được viết vào thời điểm thích hợp (lý tưởng là trước khi viết mã) + +### Mẫu AAA + +- **Arrange (Sắp xếp)**: Thiết lập điều kiện kiểm thử +- **Act (Hành động)**: Thực thi mã đang được kiểm thử +- **Assert (Khẳng định)**: Xác minh kết quả là như mong đợi + +## Các Framework Kiểm Thử Đơn Vị + +### JavaScript (Jest) + +```javascript +// math.js +function add(a, b) { + return a + b; +} + +function subtract(a, b) { + return a - b; +} + +module.exports = { add, subtract }; + +// math.test.js +const { add, subtract } = require('./math'); + +describe('Các hàm toán học', () => { + test('hàm add nên cộng hai số chính xác', () => { + // Arrange + const a = 5; + const b = 3; + + // Act + const result = add(a, b); + + // Assert + expect(result).toBe(8); + }); + + test('hàm subtract nên trừ hai số chính xác', () => { + // Arrange + const a = 5; + const b = 3; + + // Act + const result = subtract(a, b); + + // Assert + expect(result).toBe(2); + }); +}); +``` + +### Python (pytest) + +```python +# math_utils.py +def add(a, b): + return a + b + +def subtract(a, b): + return a - b + +# test_math_utils.py +import pytest +from math_utils import add, subtract + +def test_add(): + # Arrange + a = 5 + b = 3 + + # Act + result = add(a, b) + + # Assert + assert result == 8 + +def test_subtract(): + # Arrange + a = 5 + b = 3 + + # Act + result = subtract(a, b) + + # Assert + assert result == 2 +``` + +### Java (JUnit) + +```java +// MathUtils.java +public class MathUtils { + public int add(int a, int b) { + return a + b; + } + + public int subtract(int a, int b) { + return a - b; + } +} + +// MathUtilsTest.java +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.Test; + +public class MathUtilsTest { + + @Test + public void testAdd() { + // Arrange + MathUtils mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.add(a, b); + + // Assert + assertEquals(8, result); + } + + @Test + public void testSubtract() { + // Arrange + MathUtils mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.subtract(a, b); + + // Assert + assertEquals(2, result); + } +} +``` + +### C# (xUnit) + +```csharp +// MathUtils.cs +public class MathUtils +{ + public int Add(int a, int b) + { + return a + b; + } + + public int Subtract(int a, int b) + { + return a - b; + } +} + +// MathUtilsTests.cs +using Xunit; + +public class MathUtilsTests +{ + [Fact] + public void Add_ShouldCorrectlyAddTwoNumbers() + { + // Arrange + var mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.Add(a, b); + + // Assert + Assert.Equal(8, result); + } + + [Fact] + public void Subtract_ShouldCorrectlySubtractTwoNumbers() + { + // Arrange + var mathUtils = new MathUtils(); + int a = 5; + int b = 3; + + // Act + int result = mathUtils.Subtract(a, b); + + // Assert + Assert.Equal(2, result); + } +} +``` + +## Test Doubles + +Test doubles là các đối tượng thay thế các thành phần thực trong các bài kiểm thử để cô lập mã đang được kiểm thử. + +### Các Loại Test Doubles + +#### Dummy + +Các đối tượng được truyền qua nhưng không bao giờ thực sự được sử dụng. + +```javascript +// Ví dụ JavaScript +function createUser(user, logger) { + // logger không được sử dụng trong bài kiểm thử này + return { id: 123, ...user }; +} + +test('createUser nên thêm một ID vào user', () => { + // Arrange + const dummyLogger = {}; // Đối tượng giả không bao giờ được sử dụng + const user = { name: 'John' }; + + // Act + const result = createUser(user, dummyLogger); + + // Assert + expect(result.id).toBeDefined(); + expect(result.name).toBe('John'); +}); +``` + +#### Stub + +Các đối tượng cung cấp câu trả lời được định nghĩa trước cho các lời gọi được thực hiện trong quá trình kiểm thử. + +```java +// Ví dụ Java +public interface WeatherService { + int getCurrentTemperature(String city); +} + +// Triển khai stub +public class WeatherServiceStub implements WeatherService { + @Override + public int getCurrentTemperature(String city) { + return 25; // Luôn trả về 25°C bất kể thành phố nào + } +} + +@Test +public void testWeatherReporter() { + // Arrange + WeatherService stubService = new WeatherServiceStub(); + WeatherReporter reporter = new WeatherReporter(stubService); + + // Act + String report = reporter.generateReport("London"); + + // Assert + assertEquals("Nhiệt độ hiện tại ở London: 25°C", report); +} +``` + +#### Spy + +Các đối tượng ghi lại các lời gọi được thực hiện đến chúng. + +```python +# Ví dụ Python +class EmailServiceSpy: + def __init__(self): + self.emails_sent = [] + + def send_email(self, to, subject, body): + self.emails_sent.append({ + 'to': to, + 'subject': subject, + 'body': body + }) + +def test_user_registration_sends_welcome_email(): + # Arrange + email_service = EmailServiceSpy() + user_service = UserService(email_service) + + # Act + user_service.register("john@example.com", "password123") + + # Assert + assert len(email_service.emails_sent) == 1 + assert email_service.emails_sent[0]['to'] == "john@example.com" + assert "Chào mừng" in email_service.emails_sent[0]['subject'] +``` + +#### Mock + +Các đối tượng xác minh rằng các phương thức cụ thể đã được gọi với các đối số cụ thể. + +```csharp +// Ví dụ C# với Moq +[Fact] +public void Register_ShouldSendWelcomeEmail() +{ + // Arrange + var mockEmailService = new Mock(); + var userService = new UserService(mockEmailService.Object); + + // Act + userService.Register("john@example.com", "password123"); + + // Assert + mockEmailService.Verify( + x => x.SendEmail( + "john@example.com", + It.Is(s => s.Contains("Chào mừng")), + It.IsAny() + ), + Times.Once + ); +} +``` + +#### Fake + +Các đối tượng có triển khai hoạt động nhưng không phù hợp cho môi trường sản xuất. + +```javascript +// Ví dụ JavaScript +class FakeUserRepository { + constructor() { + this.users = []; + this.nextId = 1; + } + + create(userData) { + const user = { id: this.nextId++, ...userData }; + this.users.push(user); + return user; + } + + findById(id) { + return this.users.find(user => user.id === id); + } +} + +test('UserService nên tạo một người dùng', () => { + // Arrange + const fakeRepo = new FakeUserRepository(); + const userService = new UserService(fakeRepo); + + // Act + const user = userService.createUser('John', 'john@example.com'); + + // Assert + expect(user.id).toBe(1); + expect(user.name).toBe('John'); + expect(fakeRepo.findById(1)).toEqual(user); +}); +``` + +## Độ Phủ Kiểm Thử + +Độ phủ kiểm thử đo lường bao nhiêu mã của bạn được thực thi trong quá trình kiểm thử. + +### Các Số Liệu Độ Phủ + +- **Độ Phủ Dòng**: Phần trăm dòng được thực thi trong quá trình kiểm thử +- **Độ Phủ Nhánh**: Phần trăm nhánh (if/else, switch) được thực thi trong quá trình kiểm thử +- **Độ Phủ Hàm**: Phần trăm hàm được gọi trong quá trình kiểm thử +- **Độ Phủ Câu Lệnh**: Phần trăm câu lệnh được thực thi trong quá trình kiểm thử + +### Ví Dụ Báo Cáo Độ Phủ (Jest) + +``` +--------------------|---------|----------|---------|---------|------------------- +File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s +--------------------|---------|----------|---------|---------|------------------- +All files | 85.71 | 66.67 | 100 | 85.71 | + math.js | 100 | 100 | 100 | 100 | + string-utils.js | 71.43 | 33.33 | 100 | 71.43 | 15-18 +--------------------|---------|----------|---------|---------|------------------- +``` + +## Các Phương Pháp Tốt Nhất cho Kiểm Thử Đơn Vị + +1. **Kiểm Thử Một Thứ Tại Một Thời Điểm**: Mỗi bài kiểm thử nên xác minh một hành vi cụ thể. +2. **Giữ Các Bài Kiểm Thử Đơn Giản**: Các bài kiểm thử nên dễ hiểu và duy trì. +3. **Sử Dụng Tên Bài Kiểm Thử Mô Tả**: Tên nên mô tả rõ ràng những gì đang được kiểm thử. +4. **Cô Lập Đơn Vị**: Sử dụng test doubles để cô lập đơn vị khỏi các phụ thuộc của nó. +5. **Kiểm Thử Các Trường Hợp Biên**: Bao gồm các bài kiểm thử cho điều kiện biên và trường hợp lỗi. +6. **Không Kiểm Thử Framework**: Tập trung vào việc kiểm thử mã của bạn, không phải framework hoặc ngôn ngữ. +7. **Duy Trì Tính Độc Lập của Bài Kiểm Thử**: Các bài kiểm thử không nên phụ thuộc vào nhau hoặc chạy theo một thứ tự cụ thể. +8. **Tránh Logic trong Bài Kiểm Thử**: Các bài kiểm thử nên đơn giản với logic tối thiểu. +9. **Viết Bài Kiểm Thử Trước (TDD)**: Cân nhắc viết bài kiểm thử trước khi triển khai mã. +10. **Tái Cấu Trúc Bài Kiểm Thử**: Giữ bài kiểm thử sạch sẽ và có thể bảo trì, giống như mã sản xuất. + +## Phát Triển Hướng Kiểm Thử (TDD) + +TDD là một quy trình phát triển trong đó các bài kiểm thử được viết trước mã. Chu kỳ là: + +1. **Red (Đỏ)**: Viết một bài kiểm thử thất bại +2. **Green (Xanh)**: Viết mã tối thiểu để làm cho bài kiểm thử vượt qua +3. **Refactor (Tái cấu trúc)**: Cải thiện mã trong khi giữ cho các bài kiểm thử vượt qua + +### Ví Dụ TDD (JavaScript) + +```javascript +// Bước 1: Viết một bài kiểm thử thất bại +test('isPalindrome nên trả về true cho các chuỗi đối xứng', () => { + expect(isPalindrome('racecar')).toBe(true); +}); + +// Bước 2: Viết mã tối thiểu để làm cho nó vượt qua +function isPalindrome(str) { + return str === str.split('').reverse().join(''); +} + +// Bước 3: Thêm nhiều bài kiểm thử +test('isPalindrome nên trả về false cho các chuỗi không đối xứng', () => { + expect(isPalindrome('hello')).toBe(false); +}); + +test('isPalindrome nên không phân biệt chữ hoa chữ thường', () => { + expect(isPalindrome('Racecar')).toBe(true); +}); + +// Bước 4: Tái cấu trúc mã +function isPalindrome(str) { + const normalized = str.toLowerCase(); + return normalized === normalized.split('').reverse().join(''); +} +``` + +## Tài Liệu Tham Khảo + +- [Martin Fowler về Kiểm Thử Đơn Vị](https://martinfowler.com/bliki/UnitTest.html) +- [Phát Triển Hướng Kiểm Thử bởi Ví Dụ](https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530) +- [Tài Liệu Jest](https://jestjs.io/docs/getting-started) +- [Tài Liệu pytest](https://docs.pytest.org/) +- [Tài Liệu JUnit](https://junit.org/junit5/docs/current/user-guide/) +- [Tài Liệu xUnit](https://xunit.net/docs/getting-started/netcore/cmdline) diff --git a/snippets/algorithms/graph-traversal/GraphTraversal.cs b/snippets/algorithms/graph-traversal/GraphTraversal.cs new file mode 100644 index 0000000..225b3c1 --- /dev/null +++ b/snippets/algorithms/graph-traversal/GraphTraversal.cs @@ -0,0 +1,312 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; + +/** + * Graph Traversal Algorithms in C# + * + * This program demonstrates BFS and DFS traversal algorithms on a graph. + * + * Compile: dotnet build + * Run: dotnet run + */ +namespace GraphTraversalAlgorithms +{ + /// + /// A graph class using adjacency list representation + /// + public class Graph + { + // Adjacency list representation + private Dictionary> adjacencyList; + + /// + /// Initializes a new empty graph + /// + public Graph() + { + adjacencyList = new Dictionary>(); + } + + /// + /// Adds a vertex to the graph + /// + /// The vertex to add + public void AddVertex(string vertex) + { + if (!adjacencyList.ContainsKey(vertex)) + { + adjacencyList[vertex] = new List(); + } + } + + /// + /// Adds an edge between two vertices + /// + /// First vertex + /// Second vertex + public void AddEdge(string v1, string v2) + { + // Ensure both vertices exist + AddVertex(v1); + AddVertex(v2); + + // Add the edge (undirected graph) + adjacencyList[v1].Add(v2); + adjacencyList[v2].Add(v1); + } + + /// + /// Helper method to get sorted neighbors for consistent output + /// + /// The vertex to get neighbors for + /// Sorted list of neighbors + private List GetSortedNeighbors(string vertex) + { + var neighbors = new List(adjacencyList[vertex]); + neighbors.Sort(); + return neighbors; + } + + /// + /// Performs a breadth-first search traversal starting from the given vertex + /// + /// Starting vertex + /// List of vertices in the order they were visited + public List BFS(string start) + { + if (!adjacencyList.ContainsKey(start)) + { + return new List(); + } + + HashSet visited = new HashSet(); + Queue queue = new Queue(); + List result = new List(); + + // Initialize with starting vertex + visited.Add(start); + queue.Enqueue(start); + + Console.WriteLine($"Starting BFS traversal from vertex {start}"); + + while (queue.Count > 0) + { + // Dequeue the first vertex + string vertex = queue.Dequeue(); + result.Add(vertex); + + Console.WriteLine($"Visiting: {vertex}"); + Console.WriteLine($"Queue: [{string.Join(", ", queue)}]"); + Console.WriteLine($"Visited so far: [{string.Join(", ", result)}]"); + Console.WriteLine("------------------------------"); + + // Pause for demonstration + Thread.Sleep(500); + + // Get sorted neighbors for consistent order + List neighbors = GetSortedNeighbors(vertex); + + // Enqueue all unvisited neighbors + foreach (string neighbor in neighbors) + { + if (!visited.Contains(neighbor)) + { + visited.Add(neighbor); + queue.Enqueue(neighbor); + } + } + } + + return result; + } + + /// + /// Performs a recursive depth-first search traversal starting from the given vertex + /// + /// Starting vertex + /// List of vertices in the order they were visited + public List DFSRecursive(string start) + { + if (!adjacencyList.ContainsKey(start)) + { + return new List(); + } + + HashSet visited = new HashSet(); + List result = new List(); + + Console.WriteLine($"Starting recursive DFS traversal from vertex {start}"); + + DFSHelper(start, visited, result); + + return result; + } + + /// + /// Helper method for recursive DFS + /// + /// Current vertex + /// Set of visited vertices + /// List to store the traversal result + private void DFSHelper(string vertex, HashSet visited, List result) + { + // Mark as visited and add to result + visited.Add(vertex); + result.Add(vertex); + + Console.WriteLine($"Visiting: {vertex}"); + Console.WriteLine($"Visited so far: [{string.Join(", ", result)}]"); + Console.WriteLine("------------------------------"); + + // Pause for demonstration + Thread.Sleep(500); + + // Get sorted neighbors for consistent order + List neighbors = GetSortedNeighbors(vertex); + + // Recursively visit all unvisited neighbors + foreach (string neighbor in neighbors) + { + if (!visited.Contains(neighbor)) + { + DFSHelper(neighbor, visited, result); + } + } + } + + /// + /// Performs an iterative depth-first search traversal starting from the given vertex + /// + /// Starting vertex + /// List of vertices in the order they were visited + public List DFSIterative(string start) + { + if (!adjacencyList.ContainsKey(start)) + { + return new List(); + } + + HashSet visited = new HashSet(); + Stack stack = new Stack(); + List result = new List(); + + // Initialize with starting vertex + stack.Push(start); + + Console.WriteLine($"Starting iterative DFS traversal from vertex {start}"); + + while (stack.Count > 0) + { + // Pop the top vertex + string vertex = stack.Pop(); + + // If not visited, process it + if (!visited.Contains(vertex)) + { + visited.Add(vertex); + result.Add(vertex); + + Console.WriteLine($"Visiting: {vertex}"); + Console.WriteLine($"Stack: [{string.Join(", ", stack)}]"); + Console.WriteLine($"Visited so far: [{string.Join(", ", result)}]"); + Console.WriteLine("------------------------------"); + + // Pause for demonstration + Thread.Sleep(500); + + // Get sorted neighbors in reverse order for stack + List neighbors = GetSortedNeighbors(vertex); + neighbors.Reverse(); + + // Push all unvisited neighbors onto the stack + foreach (string neighbor in neighbors) + { + if (!visited.Contains(neighbor)) + { + stack.Push(neighbor); + } + } + } + } + + return result; + } + + /// + /// Prints a visualization of the graph structure + /// + public void VisualizeGraph() + { + Console.WriteLine("\nGraph Structure:"); + Console.WriteLine("------------------------------"); + + // Sort vertices for consistent output + var vertices = adjacencyList.Keys.ToList(); + vertices.Sort(); + + foreach (string vertex in vertices) + { + List neighbors = GetSortedNeighbors(vertex); + Console.WriteLine($"{vertex} -> [{string.Join(", ", neighbors)}]"); + } + + Console.WriteLine("------------------------------"); + } + } + + public class Program + { + /// + /// Creates a sample graph for demonstration + /// + /// A sample graph + public static Graph CreateSampleGraph() + { + Graph g = new Graph(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + string[,] edges = { + {"A", "B"}, {"A", "C"}, + {"B", "D"}, {"B", "E"}, + {"C", "F"}, {"E", "F"} + }; + + for (int i = 0; i < edges.GetLength(0); i++) + { + g.AddEdge(edges[i, 0], edges[i, 1]); + } + + return g; + } + + public static void Main(string[] args) + { + // Create a sample graph + Graph g = CreateSampleGraph(); + g.VisualizeGraph(); + + // Demonstrate BFS + Console.WriteLine("\n=== BFS Traversal ==="); + List bfsResult = g.BFS("A"); + Console.WriteLine($"BFS Result: [{string.Join(", ", bfsResult)}]"); + + // Demonstrate recursive DFS + Console.WriteLine("\n=== DFS Traversal (Recursive) ==="); + List dfsRecResult = g.DFSRecursive("A"); + Console.WriteLine($"DFS Recursive Result: [{string.Join(", ", dfsRecResult)}]"); + + // Demonstrate iterative DFS + Console.WriteLine("\n=== DFS Traversal (Iterative) ==="); + List dfsIterResult = g.DFSIterative("A"); + Console.WriteLine($"DFS Iterative Result: [{string.Join(", ", dfsIterResult)}]"); + } + } +} \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/GraphTraversal.java b/snippets/algorithms/graph-traversal/GraphTraversal.java new file mode 100644 index 0000000..0fce771 --- /dev/null +++ b/snippets/algorithms/graph-traversal/GraphTraversal.java @@ -0,0 +1,295 @@ +import java.util.*; + +/** + * Graph Traversal Algorithms in Java + * + * This class demonstrates BFS and DFS traversal algorithms on a graph. + * + * Compile: javac GraphTraversal.java + * Run: java GraphTraversal + */ +public class GraphTraversal { + + /** + * Graph class representing a graph using adjacency list + */ + static class Graph { + // Adjacency list representation + private Map> adjacencyList; + + /** + * Initialize an empty graph + */ + public Graph() { + this.adjacencyList = new HashMap<>(); + } + + /** + * Add a vertex to the graph + * @param vertex The vertex to add + */ + public void addVertex(String vertex) { + if (!adjacencyList.containsKey(vertex)) { + adjacencyList.put(vertex, new ArrayList<>()); + } + } + + /** + * Add an edge between two vertices + * @param v1 First vertex + * @param v2 Second vertex + */ + public void addEdge(String v1, String v2) { + // Ensure both vertices exist + addVertex(v1); + addVertex(v2); + + // Add the edge (undirected graph) + adjacencyList.get(v1).add(v2); + adjacencyList.get(v2).add(v1); + } + + /** + * Helper method to get sorted neighbors for consistent output + * @param vertex The vertex to get neighbors for + * @return Sorted list of neighbors + */ + private List getSortedNeighbors(String vertex) { + List neighbors = new ArrayList<>(adjacencyList.get(vertex)); + Collections.sort(neighbors); + return neighbors; + } + + /** + * Breadth-First Search traversal + * @param start Starting vertex + * @return List of vertices in the order they were visited + */ + public List bfs(String start) { + if (!adjacencyList.containsKey(start)) { + return new ArrayList<>(); + } + + Set visited = new HashSet<>(); + Queue queue = new LinkedList<>(); + List result = new ArrayList<>(); + + // Initialize with starting vertex + visited.add(start); + queue.add(start); + + System.out.println("Starting BFS traversal from vertex " + start); + + while (!queue.isEmpty()) { + // Dequeue the first vertex + String vertex = queue.poll(); + result.add(vertex); + + System.out.println("Visiting: " + vertex); + System.out.println("Queue: " + queue); + System.out.println("Visited so far: " + result); + System.out.println("------------------------------"); + + // Pause for demonstration + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + // Get sorted neighbors for consistent order + List neighbors = getSortedNeighbors(vertex); + + // Enqueue all unvisited neighbors + for (String neighbor : neighbors) { + if (!visited.contains(neighbor)) { + visited.add(neighbor); + queue.add(neighbor); + } + } + } + + return result; + } + + /** + * Depth-First Search traversal (recursive) + * @param start Starting vertex + * @return List of vertices in the order they were visited + */ + public List dfsRecursive(String start) { + if (!adjacencyList.containsKey(start)) { + return new ArrayList<>(); + } + + Set visited = new HashSet<>(); + List result = new ArrayList<>(); + + System.out.println("Starting recursive DFS traversal from vertex " + start); + + dfsHelper(start, visited, result); + + return result; + } + + /** + * Helper method for recursive DFS + * @param vertex Current vertex + * @param visited Set of visited vertices + * @param result List to store the traversal result + */ + private void dfsHelper(String vertex, Set visited, List result) { + // Mark as visited and add to result + visited.add(vertex); + result.add(vertex); + + System.out.println("Visiting: " + vertex); + System.out.println("Visited so far: " + result); + System.out.println("------------------------------"); + + // Pause for demonstration + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + // Get sorted neighbors for consistent order + List neighbors = getSortedNeighbors(vertex); + + // Recursively visit all unvisited neighbors + for (String neighbor : neighbors) { + if (!visited.contains(neighbor)) { + dfsHelper(neighbor, visited, result); + } + } + } + + /** + * Depth-First Search traversal (iterative) + * @param start Starting vertex + * @return List of vertices in the order they were visited + */ + public List dfsIterative(String start) { + if (!adjacencyList.containsKey(start)) { + return new ArrayList<>(); + } + + Set visited = new HashSet<>(); + Stack stack = new Stack<>(); + List result = new ArrayList<>(); + + // Initialize with starting vertex + stack.push(start); + + System.out.println("Starting iterative DFS traversal from vertex " + start); + + while (!stack.isEmpty()) { + // Pop the top vertex + String vertex = stack.pop(); + + // If not visited, process it + if (!visited.contains(vertex)) { + visited.add(vertex); + result.add(vertex); + + System.out.println("Visiting: " + vertex); + System.out.println("Stack: " + stack); + System.out.println("Visited so far: " + result); + System.out.println("------------------------------"); + + // Pause for demonstration + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + // Get sorted neighbors in reverse order for stack + List neighbors = getSortedNeighbors(vertex); + Collections.reverse(neighbors); + + // Push all unvisited neighbors onto the stack + for (String neighbor : neighbors) { + if (!visited.contains(neighbor)) { + stack.push(neighbor); + } + } + } + } + + return result; + } + + /** + * Print the graph structure + */ + public void visualizeGraph() { + System.out.println("\nGraph Structure:"); + System.out.println("------------------------------"); + + // Sort vertices for consistent output + List vertices = new ArrayList<>(adjacencyList.keySet()); + Collections.sort(vertices); + + for (String vertex : vertices) { + List neighbors = getSortedNeighbors(vertex); + System.out.println(vertex + " -> " + neighbors); + } + + System.out.println("------------------------------"); + } + } + + /** + * Create a sample graph for demonstration + * @return A sample graph + */ + public static Graph createSampleGraph() { + Graph g = new Graph(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + String[][] edges = { + {"A", "B"}, {"A", "C"}, + {"B", "D"}, {"B", "E"}, + {"C", "F"}, {"E", "F"} + }; + + for (String[] edge : edges) { + g.addEdge(edge[0], edge[1]); + } + + return g; + } + + /** + * Main method to demonstrate graph traversal algorithms + * @param args Command line arguments (not used) + */ + public static void main(String[] args) { + // Create a sample graph + Graph g = createSampleGraph(); + g.visualizeGraph(); + + // Demonstrate BFS + System.out.println("\n=== BFS Traversal ==="); + List bfsResult = g.bfs("A"); + System.out.println("BFS Result: " + bfsResult); + + // Demonstrate recursive DFS + System.out.println("\n=== DFS Traversal (Recursive) ==="); + List dfsRecResult = g.dfsRecursive("A"); + System.out.println("DFS Recursive Result: " + dfsRecResult); + + // Demonstrate iterative DFS + System.out.println("\n=== DFS Traversal (Iterative) ==="); + List dfsIterResult = g.dfsIterative("A"); + System.out.println("DFS Iterative Result: " + dfsIterResult); + } +} \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graphTraversal.js b/snippets/algorithms/graph-traversal/graphTraversal.js new file mode 100644 index 0000000..9b2c596 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graphTraversal.js @@ -0,0 +1,229 @@ +/** + * Graph Traversal Algorithms in JavaScript + * + * This module provides implementations of BFS and DFS for graph traversal. + * + * Example usage: + * node graphTraversal.js + */ + +class Graph { + /** + * Initialize an empty graph + */ + constructor() { + this.adjacencyList = {}; + } + + /** + * Add a vertex to the graph + * @param {string|number} vertex - The vertex to add + */ + addVertex(vertex) { + if (!this.adjacencyList[vertex]) { + this.adjacencyList[vertex] = []; + } + } + + /** + * Add an edge between two vertices + * @param {string|number} v1 - First vertex + * @param {string|number} v2 - Second vertex + */ + addEdge(v1, v2) { + if (!this.adjacencyList[v1]) { + this.addVertex(v1); + } + if (!this.adjacencyList[v2]) { + this.addVertex(v2); + } + + this.adjacencyList[v1].push(v2); + this.adjacencyList[v2].push(v1); // For undirected graph + } + + /** + * Breadth-First Search traversal + * @param {string|number} start - Starting vertex + * @returns {Array} - Vertices in the order they were visited + */ + bfs(start) { + if (!this.adjacencyList[start]) return []; + + const queue = [start]; + const visited = { [start]: true }; + const result = []; + + console.log(`Starting BFS traversal from vertex ${start}`); + + while (queue.length) { + const currentVertex = queue.shift(); + result.push(currentVertex); + + console.log(`Visiting: ${currentVertex}`); + console.log(`Queue: [${queue.join(', ')}]`); + console.log(`Visited so far: [${result.join(', ')}]`); + console.log('-'.repeat(30)); + + // Get neighbors and sort for consistent order + const neighbors = [...this.adjacencyList[currentVertex]].sort(); + + for (const neighbor of neighbors) { + if (!visited[neighbor]) { + visited[neighbor] = true; + queue.push(neighbor); + } + } + } + + return result; + } + + /** + * Depth-First Search traversal (recursive) + * @param {string|number} start - Starting vertex + * @returns {Array} - Vertices in the order they were visited + */ + dfsRecursive(start) { + if (!this.adjacencyList[start]) return []; + + const visited = {}; + const result = []; + + console.log(`Starting recursive DFS traversal from vertex ${start}`); + + const dfs = (vertex) => { + visited[vertex] = true; + result.push(vertex); + + console.log(`Visiting: ${vertex}`); + console.log(`Visited so far: [${result.join(', ')}]`); + console.log('-'.repeat(30)); + + // Get neighbors and sort for consistent order + const neighbors = [...this.adjacencyList[vertex]].sort(); + + for (const neighbor of neighbors) { + if (!visited[neighbor]) { + dfs(neighbor); + } + } + }; + + dfs(start); + return result; + } + + /** + * Depth-First Search traversal (iterative) + * @param {string|number} start - Starting vertex + * @returns {Array} - Vertices in the order they were visited + */ + dfsIterative(start) { + if (!this.adjacencyList[start]) return []; + + const stack = [start]; + const visited = {}; + const result = []; + + console.log(`Starting iterative DFS traversal from vertex ${start}`); + + while (stack.length) { + const currentVertex = stack.pop(); + + if (!visited[currentVertex]) { + visited[currentVertex] = true; + result.push(currentVertex); + + console.log(`Visiting: ${currentVertex}`); + console.log(`Stack: [${stack.join(', ')}]`); + console.log(`Visited so far: [${result.join(', ')}]`); + console.log('-'.repeat(30)); + + // Get neighbors and sort in reverse order for stack + const neighbors = [...this.adjacencyList[currentVertex]].sort().reverse(); + + for (const neighbor of neighbors) { + if (!visited[neighbor]) { + stack.push(neighbor); + } + } + } + } + + return result; + } + + /** + * Print a visualization of the graph structure + */ + visualizeGraph() { + console.log('\nGraph Structure:'); + console.log('-'.repeat(30)); + + // Sort the vertices for consistent output + const vertices = Object.keys(this.adjacencyList).sort(); + + for (const vertex of vertices) { + const neighbors = [...this.adjacencyList[vertex]].sort(); + console.log(`${vertex} -> [${neighbors.join(', ')}]`); + } + + console.log('-'.repeat(30)); + } +} + +/** + * Create a sample graph for demonstration + * @returns {Graph} - A sample graph + */ +function createSampleGraph() { + const g = new Graph(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + const edges = [ + ['A', 'B'], ['A', 'C'], + ['B', 'D'], ['B', 'E'], + ['C', 'F'], ['E', 'F'] + ]; + + for (const [v1, v2] of edges) { + g.addEdge(v1, v2); + } + + return g; +} + +/** + * Main function to demonstrate graph traversal algorithms + */ +function main() { + const g = createSampleGraph(); + g.visualizeGraph(); + + console.log('\n=== BFS Traversal ==='); + const bfsResult = g.bfs('A'); + console.log(`BFS Result: [${bfsResult.join(', ')}]`); + + console.log('\n=== DFS Traversal (Recursive) ==='); + const dfsRecResult = g.dfsRecursive('A'); + console.log(`DFS Recursive Result: [${dfsRecResult.join(', ')}]`); + + console.log('\n=== DFS Traversal (Iterative) ==='); + const dfsIterResult = g.dfsIterative('A'); + console.log(`DFS Iterative Result: [${dfsIterResult.join(', ')}]`); +} + +// Run the main function if this file is executed directly +if (require.main === module) { + main(); +} + +// Export the Graph class for use in other modules +module.exports = { Graph, createSampleGraph }; \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.c b/snippets/algorithms/graph-traversal/graph_traversal.c new file mode 100644 index 0000000..3ee5ea9 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.c @@ -0,0 +1,542 @@ +#include +#include +#include +#include + +/** + * Graph Traversal Algorithms in C + * + * This program demonstrates BFS and DFS traversal algorithms on a graph. + * + * Compile: gcc graph_traversal.c -o graph_traversal + * Run: ./graph_traversal + */ + +#define MAX_VERTICES 10 +#define MAX_VERTEX_NAME 10 + +// Graph structure using adjacency matrix +typedef struct { + char vertices[MAX_VERTICES][MAX_VERTEX_NAME]; + int adjacency_matrix[MAX_VERTICES][MAX_VERTICES]; + int num_vertices; +} Graph; + +// Queue for BFS traversal +typedef struct { + int items[MAX_VERTICES]; + int front; + int rear; +} Queue; + +// Stack for iterative DFS traversal +typedef struct { + int items[MAX_VERTICES]; + int top; +} Stack; + +// Queue functions +Queue* create_queue() { + Queue* q = (Queue*)malloc(sizeof(Queue)); + q->front = -1; + q->rear = -1; + return q; +} + +int is_queue_empty(Queue* q) { + return q->rear == -1; +} + +void enqueue(Queue* q, int value) { + if (q->rear == MAX_VERTICES - 1) + return; + else { + if (q->front == -1) + q->front = 0; + q->rear++; + q->items[q->rear] = value; + } +} + +int dequeue(Queue* q) { + int item; + if (is_queue_empty(q)) { + return -1; + } else { + item = q->items[q->front]; + q->front++; + if (q->front > q->rear) { + q->front = q->rear = -1; + } + return item; + } +} + +// Stack functions +Stack* create_stack() { + Stack* s = (Stack*)malloc(sizeof(Stack)); + s->top = -1; + return s; +} + +int is_stack_empty(Stack* s) { + return s->top == -1; +} + +void push(Stack* s, int value) { + if (s->top == MAX_VERTICES - 1) + return; + else { + s->top++; + s->items[s->top] = value; + } +} + +int pop(Stack* s) { + int item; + if (is_stack_empty(s)) { + return -1; + } else { + item = s->items[s->top]; + s->top--; + return item; + } +} + +// Graph functions +Graph* create_graph() { + Graph* g = (Graph*)malloc(sizeof(Graph)); + g->num_vertices = 0; + + // Initialize adjacency matrix to 0 + for (int i = 0; i < MAX_VERTICES; i++) { + for (int j = 0; j < MAX_VERTICES; j++) { + g->adjacency_matrix[i][j] = 0; + } + } + + return g; +} + +// Add a vertex to the graph +int add_vertex(Graph* g, const char* vertex) { + if (g->num_vertices >= MAX_VERTICES) { + printf("Graph is full, cannot add more vertices\n"); + return -1; + } + + // Check if vertex already exists + for (int i = 0; i < g->num_vertices; i++) { + if (strcmp(g->vertices[i], vertex) == 0) { + return i; + } + } + + // Add new vertex + strcpy(g->vertices[g->num_vertices], vertex); + return g->num_vertices++; +} + +// Add an edge between two vertices +void add_edge(Graph* g, const char* v1, const char* v2) { + // Ensure both vertices exist + int v1_idx = add_vertex(g, v1); + int v2_idx = add_vertex(g, v2); + + if (v1_idx == -1 || v2_idx == -1) { + return; + } + + // Add the edge (undirected graph) + g->adjacency_matrix[v1_idx][v2_idx] = 1; + g->adjacency_matrix[v2_idx][v1_idx] = 1; +} + +// Print neighbors in sorted order +void print_sorted_neighbors(Graph* g, int vertex_idx) { + // Create a sorted copy of neighbors + int neighbors[MAX_VERTICES]; + int count = 0; + + for (int i = 0; i < g->num_vertices; i++) { + if (g->adjacency_matrix[vertex_idx][i]) { + neighbors[count++] = i; + } + } + + // Simple bubble sort + for (int i = 0; i < count - 1; i++) { + for (int j = 0; j < count - i - 1; j++) { + if (strcmp(g->vertices[neighbors[j]], g->vertices[neighbors[j + 1]]) > 0) { + int temp = neighbors[j]; + neighbors[j] = neighbors[j + 1]; + neighbors[j + 1] = temp; + } + } + } + + printf("["); + for (int i = 0; i < count; i++) { + printf("%s", g->vertices[neighbors[i]]); + if (i < count - 1) { + printf(", "); + } + } + printf("]"); +} + +// Get the index of a vertex by name +int get_vertex_index(Graph* g, const char* vertex) { + for (int i = 0; i < g->num_vertices; i++) { + if (strcmp(g->vertices[i], vertex) == 0) { + return i; + } + } + return -1; +} + +// BFS traversal +void bfs(Graph* g, const char* start) { + int start_idx = get_vertex_index(g, start); + if (start_idx == -1) { + printf("Starting vertex not found\n"); + return; + } + + int visited[MAX_VERTICES] = {0}; + int result[MAX_VERTICES]; + int result_count = 0; + + Queue* q = create_queue(); + + // Initialize with starting vertex + visited[start_idx] = 1; + enqueue(q, start_idx); + + printf("Starting BFS traversal from vertex %s\n", start); + + while (!is_queue_empty(q)) { + // Dequeue the first vertex + int vertex = dequeue(q); + result[result_count++] = vertex; + + printf("Visiting: %s\n", g->vertices[vertex]); + + // Print queue contents + printf("Queue: ["); + for (int i = q->front; i <= q->rear; i++) { + printf("%s", g->vertices[q->items[i]]); + if (i < q->rear) { + printf(", "); + } + } + printf("]\n"); + + // Print visited vertices + printf("Visited so far: ["); + for (int i = 0; i < result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < result_count - 1) { + printf(", "); + } + } + printf("]\n"); + printf("------------------------------\n"); + + // Pause for demonstration + usleep(500000); // 500ms + + // Visit neighbors in sorted order + int neighbors[MAX_VERTICES]; + int count = 0; + + for (int i = 0; i < g->num_vertices; i++) { + if (g->adjacency_matrix[vertex][i]) { + neighbors[count++] = i; + } + } + + // Simple bubble sort + for (int i = 0; i < count - 1; i++) { + for (int j = 0; j < count - i - 1; j++) { + if (strcmp(g->vertices[neighbors[j]], g->vertices[neighbors[j + 1]]) > 0) { + int temp = neighbors[j]; + neighbors[j] = neighbors[j + 1]; + neighbors[j + 1] = temp; + } + } + } + + // Enqueue all unvisited neighbors + for (int i = 0; i < count; i++) { + int neighbor = neighbors[i]; + if (!visited[neighbor]) { + visited[neighbor] = 1; + enqueue(q, neighbor); + } + } + } + + free(q); + + // Print final result + printf("BFS Result: ["); + for (int i = 0; i < result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < result_count - 1) { + printf(", "); + } + } + printf("]\n"); +} + +// Helper for recursive DFS +void dfs_helper(Graph* g, int vertex, int* visited, int* result, int* result_count) { + // Mark as visited and add to result + visited[vertex] = 1; + result[(*result_count)++] = vertex; + + printf("Visiting: %s\n", g->vertices[vertex]); + + // Print visited vertices + printf("Visited so far: ["); + for (int i = 0; i < *result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < *result_count - 1) { + printf(", "); + } + } + printf("]\n"); + printf("------------------------------\n"); + + // Pause for demonstration + usleep(500000); // 500ms + + // Visit neighbors in sorted order + int neighbors[MAX_VERTICES]; + int count = 0; + + for (int i = 0; i < g->num_vertices; i++) { + if (g->adjacency_matrix[vertex][i]) { + neighbors[count++] = i; + } + } + + // Simple bubble sort + for (int i = 0; i < count - 1; i++) { + for (int j = 0; j < count - i - 1; j++) { + if (strcmp(g->vertices[neighbors[j]], g->vertices[neighbors[j + 1]]) > 0) { + int temp = neighbors[j]; + neighbors[j] = neighbors[j + 1]; + neighbors[j + 1] = temp; + } + } + } + + // Recursively visit all unvisited neighbors + for (int i = 0; i < count; i++) { + int neighbor = neighbors[i]; + if (!visited[neighbor]) { + dfs_helper(g, neighbor, visited, result, result_count); + } + } +} + +// DFS traversal (recursive) +void dfs_recursive(Graph* g, const char* start) { + int start_idx = get_vertex_index(g, start); + if (start_idx == -1) { + printf("Starting vertex not found\n"); + return; + } + + int visited[MAX_VERTICES] = {0}; + int result[MAX_VERTICES]; + int result_count = 0; + + printf("Starting recursive DFS traversal from vertex %s\n", start); + + dfs_helper(g, start_idx, visited, result, &result_count); + + // Print final result + printf("DFS Recursive Result: ["); + for (int i = 0; i < result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < result_count - 1) { + printf(", "); + } + } + printf("]\n"); +} + +// DFS traversal (iterative) +void dfs_iterative(Graph* g, const char* start) { + int start_idx = get_vertex_index(g, start); + if (start_idx == -1) { + printf("Starting vertex not found\n"); + return; + } + + int visited[MAX_VERTICES] = {0}; + int result[MAX_VERTICES]; + int result_count = 0; + + Stack* s = create_stack(); + + // Initialize with starting vertex + push(s, start_idx); + + printf("Starting iterative DFS traversal from vertex %s\n", start); + + while (!is_stack_empty(s)) { + // Pop the top vertex + int vertex = pop(s); + + // If not visited, process it + if (!visited[vertex]) { + visited[vertex] = 1; + result[result_count++] = vertex; + + printf("Visiting: %s\n", g->vertices[vertex]); + + // Print stack contents + printf("Stack: ["); + for (int i = 0; i <= s->top; i++) { + printf("%s", g->vertices[s->items[i]]); + if (i < s->top) { + printf(", "); + } + } + printf("]\n"); + + // Print visited vertices + printf("Visited so far: ["); + for (int i = 0; i < result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < result_count - 1) { + printf(", "); + } + } + printf("]\n"); + printf("------------------------------\n"); + + // Pause for demonstration + usleep(500000); // 500ms + + // Visit neighbors in reverse sorted order for stack + int neighbors[MAX_VERTICES]; + int count = 0; + + for (int i = 0; i < g->num_vertices; i++) { + if (g->adjacency_matrix[vertex][i]) { + neighbors[count++] = i; + } + } + + // Simple bubble sort (in reverse order) + for (int i = 0; i < count - 1; i++) { + for (int j = 0; j < count - i - 1; j++) { + if (strcmp(g->vertices[neighbors[j]], g->vertices[neighbors[j + 1]]) < 0) { + int temp = neighbors[j]; + neighbors[j] = neighbors[j + 1]; + neighbors[j + 1] = temp; + } + } + } + + // Push all unvisited neighbors onto the stack + for (int i = 0; i < count; i++) { + int neighbor = neighbors[i]; + if (!visited[neighbor]) { + push(s, neighbor); + } + } + } + } + + free(s); + + // Print final result + printf("DFS Iterative Result: ["); + for (int i = 0; i < result_count; i++) { + printf("%s", g->vertices[result[i]]); + if (i < result_count - 1) { + printf(", "); + } + } + printf("]\n"); +} + +// Visualize the graph structure +void visualize_graph(Graph* g) { + printf("\nGraph Structure:\n"); + printf("------------------------------\n"); + + // Sort vertices for consistent output + int sorted_indices[MAX_VERTICES]; + for (int i = 0; i < g->num_vertices; i++) { + sorted_indices[i] = i; + } + + // Simple bubble sort + for (int i = 0; i < g->num_vertices - 1; i++) { + for (int j = 0; j < g->num_vertices - i - 1; j++) { + if (strcmp(g->vertices[sorted_indices[j]], g->vertices[sorted_indices[j + 1]]) > 0) { + int temp = sorted_indices[j]; + sorted_indices[j] = sorted_indices[j + 1]; + sorted_indices[j + 1] = temp; + } + } + } + + for (int i = 0; i < g->num_vertices; i++) { + int vertex = sorted_indices[i]; + printf("%s -> ", g->vertices[vertex]); + print_sorted_neighbors(g, vertex); + printf("\n"); + } + + printf("------------------------------\n"); +} + +// Create a sample graph for demonstration +Graph* create_sample_graph() { + Graph* g = create_graph(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + add_edge(g, "A", "B"); + add_edge(g, "A", "C"); + add_edge(g, "B", "D"); + add_edge(g, "B", "E"); + add_edge(g, "C", "F"); + add_edge(g, "E", "F"); + + return g; +} + +int main() { + // Create a sample graph + Graph* g = create_sample_graph(); + visualize_graph(g); + + // Demonstrate BFS + printf("\n=== BFS Traversal ===\n"); + bfs(g, "A"); + + // Demonstrate recursive DFS + printf("\n=== DFS Traversal (Recursive) ===\n"); + dfs_recursive(g, "A"); + + // Demonstrate iterative DFS + printf("\n=== DFS Traversal (Iterative) ===\n"); + dfs_iterative(g, "A"); + + free(g); + return 0; +} \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.cpp b/snippets/algorithms/graph-traversal/graph_traversal.cpp new file mode 100644 index 0000000..a63c87d --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.cpp @@ -0,0 +1,318 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Graph Traversal Algorithms in C++ + * + * This program demonstrates BFS and DFS traversal algorithms on a graph. + * + * Compile: g++ -std=c++11 graph_traversal.cpp -o graph_traversal + * Run: ./graph_traversal + */ + +class Graph { +private: + // Adjacency list representation + std::unordered_map> adjacencyList; + + // Helper function to get sorted neighbors for consistent output + std::vector getSortedNeighbors(const std::string& vertex) const { + std::vector neighbors = adjacencyList.at(vertex); + std::sort(neighbors.begin(), neighbors.end()); + return neighbors; + } + + // Helper for recursive DFS + void dfsHelper(const std::string& vertex, std::unordered_set& visited, + std::vector& result) const { + // Mark as visited and add to result + visited.insert(vertex); + result.push_back(vertex); + + std::cout << "Visiting: " << vertex << std::endl; + std::cout << "Visited so far: ["; + for (size_t i = 0; i < result.size(); ++i) { + std::cout << result[i]; + if (i < result.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + std::cout << "------------------------------" << std::endl; + + // Pause for demonstration + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + + // Get sorted neighbors for consistent order + std::vector neighbors = getSortedNeighbors(vertex); + + // Recursively visit all unvisited neighbors + for (const auto& neighbor : neighbors) { + if (visited.find(neighbor) == visited.end()) { + dfsHelper(neighbor, visited, result); + } + } + } + +public: + // Add a vertex to the graph + void addVertex(const std::string& vertex) { + if (adjacencyList.find(vertex) == adjacencyList.end()) { + adjacencyList[vertex] = std::vector(); + } + } + + // Add an edge between two vertices + void addEdge(const std::string& v1, const std::string& v2) { + // Ensure both vertices exist + addVertex(v1); + addVertex(v2); + + // Add the edge (undirected graph) + adjacencyList[v1].push_back(v2); + adjacencyList[v2].push_back(v1); + } + + // Breadth-First Search traversal + std::vector bfs(const std::string& start) const { + if (adjacencyList.find(start) == adjacencyList.end()) { + return {}; + } + + std::unordered_set visited; + std::queue queue; + std::vector result; + + // Initialize with starting vertex + visited.insert(start); + queue.push(start); + + std::cout << "Starting BFS traversal from vertex " << start << std::endl; + + while (!queue.empty()) { + // Dequeue the first vertex + std::string vertex = queue.front(); + queue.pop(); + result.push_back(vertex); + + std::cout << "Visiting: " << vertex << std::endl; + + // Print queue contents + std::cout << "Queue: ["; + std::queue queueCopy = queue; + bool first = true; + while (!queueCopy.empty()) { + if (!first) std::cout << ", "; + std::cout << queueCopy.front(); + queueCopy.pop(); + first = false; + } + std::cout << "]" << std::endl; + + // Print visited vertices + std::cout << "Visited so far: ["; + for (size_t i = 0; i < result.size(); ++i) { + std::cout << result[i]; + if (i < result.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + std::cout << "------------------------------" << std::endl; + + // Pause for demonstration + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + + // Get sorted neighbors for consistent order + std::vector neighbors = getSortedNeighbors(vertex); + + // Enqueue all unvisited neighbors + for (const auto& neighbor : neighbors) { + if (visited.find(neighbor) == visited.end()) { + visited.insert(neighbor); + queue.push(neighbor); + } + } + } + + return result; + } + + // Depth-First Search traversal (recursive) + std::vector dfsRecursive(const std::string& start) const { + if (adjacencyList.find(start) == adjacencyList.end()) { + return {}; + } + + std::unordered_set visited; + std::vector result; + + std::cout << "Starting recursive DFS traversal from vertex " << start << std::endl; + + dfsHelper(start, visited, result); + + return result; + } + + // Depth-First Search traversal (iterative) + std::vector dfsIterative(const std::string& start) const { + if (adjacencyList.find(start) == adjacencyList.end()) { + return {}; + } + + std::unordered_set visited; + std::stack stack; + std::vector result; + + // Initialize with starting vertex + stack.push(start); + + std::cout << "Starting iterative DFS traversal from vertex " << start << std::endl; + + while (!stack.empty()) { + // Pop the top vertex + std::string vertex = stack.top(); + stack.pop(); + + // If not visited, process it + if (visited.find(vertex) == visited.end()) { + visited.insert(vertex); + result.push_back(vertex); + + std::cout << "Visiting: " << vertex << std::endl; + + // Print stack contents (in reverse order since it's LIFO) + std::cout << "Stack: ["; + std::vector stackContents; + std::stack stackCopy = stack; + while (!stackCopy.empty()) { + stackContents.push_back(stackCopy.top()); + stackCopy.pop(); + } + std::reverse(stackContents.begin(), stackContents.end()); + for (size_t i = 0; i < stackContents.size(); ++i) { + std::cout << stackContents[i]; + if (i < stackContents.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + + // Print visited vertices + std::cout << "Visited so far: ["; + for (size_t i = 0; i < result.size(); ++i) { + std::cout << result[i]; + if (i < result.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + std::cout << "------------------------------" << std::endl; + + // Pause for demonstration + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + + // Get sorted neighbors in reverse order for stack + std::vector neighbors = getSortedNeighbors(vertex); + std::reverse(neighbors.begin(), neighbors.end()); + + // Push all unvisited neighbors onto the stack + for (const auto& neighbor : neighbors) { + if (visited.find(neighbor) == visited.end()) { + stack.push(neighbor); + } + } + } + } + + return result; + } + + // Print the graph structure + void visualizeGraph() const { + std::cout << "\nGraph Structure:" << std::endl; + std::cout << "------------------------------" << std::endl; + + // Sort vertices for consistent output + std::vector vertices; + for (const auto& pair : adjacencyList) { + vertices.push_back(pair.first); + } + std::sort(vertices.begin(), vertices.end()); + + for (const auto& vertex : vertices) { + std::vector neighbors = getSortedNeighbors(vertex); + + std::cout << vertex << " -> ["; + for (size_t i = 0; i < neighbors.size(); ++i) { + std::cout << neighbors[i]; + if (i < neighbors.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + } + + std::cout << "------------------------------" << std::endl; + } +}; + +// Create a sample graph for demonstration +Graph createSampleGraph() { + Graph g; + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + std::vector> edges = { + {"A", "B"}, {"A", "C"}, + {"B", "D"}, {"B", "E"}, + {"C", "F"}, {"E", "F"} + }; + + for (const auto& edge : edges) { + g.addEdge(edge.first, edge.second); + } + + return g; +} + +// Main function +int main() { + // Create a sample graph + Graph g = createSampleGraph(); + g.visualizeGraph(); + + // Demonstrate BFS + std::cout << "\n=== BFS Traversal ===" << std::endl; + std::vector bfsResult = g.bfs("A"); + std::cout << "BFS Result: ["; + for (size_t i = 0; i < bfsResult.size(); ++i) { + std::cout << bfsResult[i]; + if (i < bfsResult.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + + // Demonstrate recursive DFS + std::cout << "\n=== DFS Traversal (Recursive) ===" << std::endl; + std::vector dfsRecResult = g.dfsRecursive("A"); + std::cout << "DFS Recursive Result: ["; + for (size_t i = 0; i < dfsRecResult.size(); ++i) { + std::cout << dfsRecResult[i]; + if (i < dfsRecResult.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + + // Demonstrate iterative DFS + std::cout << "\n=== DFS Traversal (Iterative) ===" << std::endl; + std::vector dfsIterResult = g.dfsIterative("A"); + std::cout << "DFS Iterative Result: ["; + for (size_t i = 0; i < dfsIterResult.size(); ++i) { + std::cout << dfsIterResult[i]; + if (i < dfsIterResult.size() - 1) std::cout << ", "; + } + std::cout << "]" << std::endl; + + return 0; +} \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.go b/snippets/algorithms/graph-traversal/graph_traversal.go new file mode 100644 index 0000000..56a5d72 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.go @@ -0,0 +1,242 @@ +package main + +import ( + "fmt" + "sort" + "time" +) + +// Graph represents an undirected graph using an adjacency list +type Graph struct { + adjacencyList map[string][]string +} + +// NewGraph creates a new empty graph +func NewGraph() *Graph { + return &Graph{ + adjacencyList: make(map[string][]string), + } +} + +// AddVertex adds a vertex to the graph +func (g *Graph) AddVertex(vertex string) { + if _, exists := g.adjacencyList[vertex]; !exists { + g.adjacencyList[vertex] = []string{} + } +} + +// AddEdge adds an edge between two vertices +func (g *Graph) AddEdge(v1, v2 string) { + // Ensure both vertices exist + g.AddVertex(v1) + g.AddVertex(v2) + + // Add the edge (for undirected graph) + g.adjacencyList[v1] = append(g.adjacencyList[v1], v2) + g.adjacencyList[v2] = append(g.adjacencyList[v2], v1) +} + +// BFS performs a breadth-first search traversal starting from the given vertex +func (g *Graph) BFS(start string) []string { + if _, exists := g.adjacencyList[start]; !exists { + return []string{} + } + + // Initialize data structures + visited := make(map[string]bool) + visited[start] = true + + queue := []string{start} + result := []string{} + + fmt.Printf("Starting BFS traversal from vertex %s\n", start) + + // BFS traversal + for len(queue) > 0 { + // Dequeue the first vertex + vertex := queue[0] + queue = queue[1:] + result = append(result, vertex) + + fmt.Printf("Visiting: %s\n", vertex) + fmt.Printf("Queue: %v\n", queue) + fmt.Printf("Visited so far: %v\n", result) + fmt.Println("------------------------------") + time.Sleep(500 * time.Millisecond) // Slow down for demonstration + + // Get sorted neighbors for consistent order + neighbors := g.getSortedNeighbors(vertex) + + // Enqueue all unvisited neighbors + for _, neighbor := range neighbors { + if !visited[neighbor] { + visited[neighbor] = true + queue = append(queue, neighbor) + } + } + } + + return result +} + +// DFSRecursive performs a recursive depth-first search traversal starting from the given vertex +func (g *Graph) DFSRecursive(start string) []string { + if _, exists := g.adjacencyList[start]; !exists { + return []string{} + } + + // Initialize data structures + visited := make(map[string]bool) + result := []string{} + + fmt.Printf("Starting recursive DFS traversal from vertex %s\n", start) + + // Define the recursive helper function + var dfs func(vertex string) + dfs = func(vertex string) { + // Mark as visited and add to result + visited[vertex] = true + result = append(result, vertex) + + fmt.Printf("Visiting: %s\n", vertex) + fmt.Printf("Visited so far: %v\n", result) + fmt.Println("------------------------------") + time.Sleep(500 * time.Millisecond) // Slow down for demonstration + + // Get sorted neighbors for consistent order + neighbors := g.getSortedNeighbors(vertex) + + // Recursively visit all unvisited neighbors + for _, neighbor := range neighbors { + if !visited[neighbor] { + dfs(neighbor) + } + } + } + + // Start the DFS traversal + dfs(start) + return result +} + +// DFSIterative performs an iterative depth-first search traversal starting from the given vertex +func (g *Graph) DFSIterative(start string) []string { + if _, exists := g.adjacencyList[start]; !exists { + return []string{} + } + + // Initialize data structures + visited := make(map[string]bool) + stack := []string{start} + result := []string{} + + fmt.Printf("Starting iterative DFS traversal from vertex %s\n", start) + + // DFS traversal using a stack + for len(stack) > 0 { + // Pop the last vertex from the stack + lastIndex := len(stack) - 1 + vertex := stack[lastIndex] + stack = stack[:lastIndex] + + // If not visited, process it + if !visited[vertex] { + visited[vertex] = true + result = append(result, vertex) + + fmt.Printf("Visiting: %s\n", vertex) + fmt.Printf("Stack: %v\n", stack) + fmt.Printf("Visited so far: %v\n", result) + fmt.Println("------------------------------") + time.Sleep(500 * time.Millisecond) // Slow down for demonstration + + // Get sorted neighbors in reverse order for stack + neighbors := g.getSortedNeighbors(vertex) + // Reverse the order for stack to simulate recursive DFS + for i, j := 0, len(neighbors)-1; i < j; i, j = i+1, j-1 { + neighbors[i], neighbors[j] = neighbors[j], neighbors[i] + } + + // Push all unvisited neighbors onto the stack + for _, neighbor := range neighbors { + if !visited[neighbor] { + stack = append(stack, neighbor) + } + } + } + } + + return result +} + +// VisualizeGraph prints a visualization of the graph structure +func (g *Graph) VisualizeGraph() { + fmt.Println("\nGraph Structure:") + fmt.Println("------------------------------") + + // Sort vertices for consistent output + var vertices []string + for vertex := range g.adjacencyList { + vertices = append(vertices, vertex) + } + sort.Strings(vertices) + + for _, vertex := range vertices { + neighbors := g.getSortedNeighbors(vertex) + fmt.Printf("%s -> %v\n", vertex, neighbors) + } + + fmt.Println("------------------------------") +} + +// getSortedNeighbors returns the sorted neighbors of a vertex +func (g *Graph) getSortedNeighbors(vertex string) []string { + neighbors := g.adjacencyList[vertex] + sort.Strings(neighbors) + return neighbors +} + +// CreateSampleGraph creates a sample graph for demonstration +func CreateSampleGraph() *Graph { + g := NewGraph() + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + edges := [][2]string{ + {"A", "B"}, {"A", "C"}, + {"B", "D"}, {"B", "E"}, + {"C", "F"}, {"E", "F"}, + } + + for _, edge := range edges { + g.AddEdge(edge[0], edge[1]) + } + + return g +} + +func main() { + // Create a sample graph + g := CreateSampleGraph() + g.VisualizeGraph() + + // Demonstrate BFS + fmt.Println("\n=== BFS Traversal ===") + bfsResult := g.BFS("A") + fmt.Printf("BFS Result: %v\n", bfsResult) + + // Demonstrate recursive DFS + fmt.Println("\n=== DFS Traversal (Recursive) ===") + dfsRecResult := g.DFSRecursive("A") + fmt.Printf("DFS Recursive Result: %v\n", dfsRecResult) + + // Demonstrate iterative DFS + fmt.Println("\n=== DFS Traversal (Iterative) ===") + dfsIterResult := g.DFSIterative("A") + fmt.Printf("DFS Iterative Result: %v\n", dfsIterResult) +} \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.php b/snippets/algorithms/graph-traversal/graph_traversal.php new file mode 100644 index 0000000..17175b2 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.php @@ -0,0 +1,268 @@ +adjacencyList[$vertex])) { + $this->adjacencyList[$vertex] = []; + } + } + + /** + * Adds an edge between two vertices + * + * @param string $v1 First vertex + * @param string $v2 Second vertex + */ + public function addEdge($v1, $v2) { + // Ensure both vertices exist + $this->addVertex($v1); + $this->addVertex($v2); + + // Add the edge (undirected graph) + $this->adjacencyList[$v1][] = $v2; + $this->adjacencyList[$v2][] = $v1; + } + + /** + * Helper method to get sorted neighbors for consistent output + * + * @param string $vertex The vertex to get neighbors for + * @return array Sorted array of neighbors + */ + private function getSortedNeighbors($vertex) { + $neighbors = $this->adjacencyList[$vertex]; + sort($neighbors); + return $neighbors; + } + + /** + * Performs a breadth-first search traversal starting from the given vertex + * + * @param string $start Starting vertex + * @return array Array of vertices in the order they were visited + */ + public function bfs($start) { + if (!isset($this->adjacencyList[$start])) { + return []; + } + + $visited = [$start => true]; + $queue = [$start]; + $result = []; + + echo "Starting BFS traversal from vertex $start\n"; + + while (count($queue) > 0) { + // Dequeue the first vertex + $vertex = array_shift($queue); + $result[] = $vertex; + + echo "Visiting: $vertex\n"; + echo "Queue: [" . implode(", ", $queue) . "]\n"; + echo "Visited so far: [" . implode(", ", $result) . "]\n"; + echo "------------------------------\n"; + + // Pause for demonstration + usleep(500000); // 500ms + + // Get sorted neighbors for consistent order + $neighbors = $this->getSortedNeighbors($vertex); + + // Enqueue all unvisited neighbors + foreach ($neighbors as $neighbor) { + if (!isset($visited[$neighbor])) { + $visited[$neighbor] = true; + $queue[] = $neighbor; + } + } + } + + return $result; + } + + /** + * Performs a recursive depth-first search traversal starting from the given vertex + * + * @param string $start Starting vertex + * @return array Array of vertices in the order they were visited + */ + public function dfsRecursive($start) { + if (!isset($this->adjacencyList[$start])) { + return []; + } + + $visited = []; + $result = []; + + echo "Starting recursive DFS traversal from vertex $start\n"; + + $this->dfsHelper($start, $visited, $result); + + return $result; + } + + /** + * Helper method for recursive DFS + * + * @param string $vertex Current vertex + * @param array &$visited Reference to array of visited vertices + * @param array &$result Reference to array to store the traversal result + */ + private function dfsHelper($vertex, &$visited, &$result) { + // Mark as visited and add to result + $visited[$vertex] = true; + $result[] = $vertex; + + echo "Visiting: $vertex\n"; + echo "Visited so far: [" . implode(", ", $result) . "]\n"; + echo "------------------------------\n"; + + // Pause for demonstration + usleep(500000); // 500ms + + // Get sorted neighbors for consistent order + $neighbors = $this->getSortedNeighbors($vertex); + + // Recursively visit all unvisited neighbors + foreach ($neighbors as $neighbor) { + if (!isset($visited[$neighbor])) { + $this->dfsHelper($neighbor, $visited, $result); + } + } + } + + /** + * Performs an iterative depth-first search traversal starting from the given vertex + * + * @param string $start Starting vertex + * @return array Array of vertices in the order they were visited + */ + public function dfsIterative($start) { + if (!isset($this->adjacencyList[$start])) { + return []; + } + + $visited = []; + $stack = [$start]; + $result = []; + + echo "Starting iterative DFS traversal from vertex $start\n"; + + while (count($stack) > 0) { + // Pop the top vertex + $vertex = array_pop($stack); + + // If not visited, process it + if (!isset($visited[$vertex])) { + $visited[$vertex] = true; + $result[] = $vertex; + + echo "Visiting: $vertex\n"; + echo "Stack: [" . implode(", ", $stack) . "]\n"; + echo "Visited so far: [" . implode(", ", $result) . "]\n"; + echo "------------------------------\n"; + + // Pause for demonstration + usleep(500000); // 500ms + + // Get sorted neighbors in reverse order for stack + $neighbors = $this->getSortedNeighbors($vertex); + $neighbors = array_reverse($neighbors); + + // Push all unvisited neighbors onto the stack + foreach ($neighbors as $neighbor) { + if (!isset($visited[$neighbor])) { + $stack[] = $neighbor; + } + } + } + } + + return $result; + } + + /** + * Prints a visualization of the graph structure + */ + public function visualizeGraph() { + echo "\nGraph Structure:\n"; + echo "------------------------------\n"; + + // Sort vertices for consistent output + $vertices = array_keys($this->adjacencyList); + sort($vertices); + + foreach ($vertices as $vertex) { + $neighbors = $this->getSortedNeighbors($vertex); + echo "$vertex -> [" . implode(", ", $neighbors) . "]\n"; + } + + echo "------------------------------\n"; + } +} + +/** + * Creates a sample graph for demonstration + * + * @return Graph A sample graph + */ +function createSampleGraph() { + $g = new Graph(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + $edges = [ + ["A", "B"], ["A", "C"], + ["B", "D"], ["B", "E"], + ["C", "F"], ["E", "F"] + ]; + + foreach ($edges as $edge) { + $g->addEdge($edge[0], $edge[1]); + } + + return $g; +} + +// Main execution +$g = createSampleGraph(); +$g->visualizeGraph(); + +// Demonstrate BFS +echo "\n=== BFS Traversal ===\n"; +$bfsResult = $g->bfs("A"); +echo "BFS Result: [" . implode(", ", $bfsResult) . "]\n"; + +// Demonstrate recursive DFS +echo "\n=== DFS Traversal (Recursive) ===\n"; +$dfsRecResult = $g->dfsRecursive("A"); +echo "DFS Recursive Result: [" . implode(", ", $dfsRecResult) . "]\n"; + +// Demonstrate iterative DFS +echo "\n=== DFS Traversal (Iterative) ===\n"; +$dfsIterResult = $g->dfsIterative("A"); +echo "DFS Iterative Result: [" . implode(", ", $dfsIterResult) . "]\n"; +?> \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.py b/snippets/algorithms/graph-traversal/graph_traversal.py new file mode 100644 index 0000000..364ec40 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +""" +Graph Traversal Algorithms Implementation + +This module provides implementations of BFS and DFS for graph traversal, +along with a visualization function to display the traversal order. + +Example usage: + python graph_traversal_example.py +""" + +from collections import deque +import time + + +class Graph: + """A simple graph representation using adjacency lists.""" + + def __init__(self): + """Initialize an empty graph.""" + self.graph = {} + + def add_vertex(self, vertex): + """Add a vertex to the graph if it doesn't exist.""" + if vertex not in self.graph: + self.graph[vertex] = [] + + def add_edge(self, v1, v2): + """Add an edge between v1 and v2.""" + if v1 not in self.graph: + self.add_vertex(v1) + if v2 not in self.graph: + self.add_vertex(v2) + + self.graph[v1].append(v2) + self.graph[v2].append(v1) # For undirected graph + + def bfs(self, start): + """ + Perform Breadth-First Search starting from the given vertex. + + Args: + start: The starting vertex for BFS + + Returns: + A list containing vertices in the order they were visited + """ + if start not in self.graph: + return [] + + visited = set([start]) + queue = deque([start]) + result = [] + + print(f"Starting BFS traversal from vertex {start}") + + while queue: + vertex = queue.popleft() + result.append(vertex) + + print(f"Visiting: {vertex}") + print(f"Queue: {list(queue)}") + print(f"Visited so far: {result}") + print("-" * 30) + time.sleep(0.5) # Slow down for demonstration + + for neighbor in sorted(self.graph[vertex]): # Sort for consistent order + if neighbor not in visited: + visited.add(neighbor) + queue.append(neighbor) + + return result + + def dfs_recursive(self, start): + """ + Perform Depth-First Search recursively starting from the given vertex. + + Args: + start: The starting vertex for DFS + + Returns: + A list containing vertices in the order they were visited + """ + if start not in self.graph: + return [] + + visited = set() + result = [] + + print(f"Starting recursive DFS traversal from vertex {start}") + + def dfs_helper(vertex): + visited.add(vertex) + result.append(vertex) + + print(f"Visiting: {vertex}") + print(f"Visited so far: {result}") + print("-" * 30) + time.sleep(0.5) # Slow down for demonstration + + for neighbor in sorted(self.graph[vertex]): # Sort for consistent order + if neighbor not in visited: + dfs_helper(neighbor) + + dfs_helper(start) + return result + + def dfs_iterative(self, start): + """ + Perform Depth-First Search iteratively starting from the given vertex. + + Args: + start: The starting vertex for DFS + + Returns: + A list containing vertices in the order they were visited + """ + if start not in self.graph: + return [] + + visited = set() + stack = [start] + result = [] + + print(f"Starting iterative DFS traversal from vertex {start}") + + while stack: + vertex = stack.pop() + + if vertex not in visited: + visited.add(vertex) + result.append(vertex) + + print(f"Visiting: {vertex}") + print(f"Stack: {stack}") + print(f"Visited so far: {result}") + print("-" * 30) + time.sleep(0.5) # Slow down for demonstration + + # Add neighbors in reverse sorted order to simulate recursive DFS + for neighbor in sorted(self.graph[vertex], reverse=True): + if neighbor not in visited: + stack.append(neighbor) + + return result + + def visualize_graph(self): + """Print a simple visualization of the graph structure.""" + print("\nGraph Structure:") + print("-" * 30) + for vertex, neighbors in sorted(self.graph.items()): + print(f"{vertex} -> {sorted(neighbors)}") + print("-" * 30) + + +def create_sample_graph(): + """Create a sample graph for demonstration.""" + g = Graph() + + # Add edges to build this graph: + # A + # / \ + # B C + # / \ \ + # D E---F + + edges = [ + ('A', 'B'), ('A', 'C'), + ('B', 'D'), ('B', 'E'), + ('C', 'F'), ('E', 'F') + ] + + for v1, v2 in edges: + g.add_edge(v1, v2) + + return g + + +def main(): + """Main function to demonstrate graph traversal algorithms.""" + g = create_sample_graph() + g.visualize_graph() + + print("\n=== BFS Traversal ===") + bfs_result = g.bfs('A') + print(f"BFS Result: {bfs_result}") + + print("\n=== DFS Traversal (Recursive) ===") + dfs_rec_result = g.dfs_recursive('A') + print(f"DFS Recursive Result: {dfs_rec_result}") + + print("\n=== DFS Traversal (Iterative) ===") + dfs_iter_result = g.dfs_iterative('A') + print(f"DFS Iterative Result: {dfs_iter_result}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.rb b/snippets/algorithms/graph-traversal/graph_traversal.rb new file mode 100644 index 0000000..f5ba55f --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.rb @@ -0,0 +1,208 @@ +#!/usr/bin/env ruby + +# Graph Traversal Algorithms in Ruby +# +# This script demonstrates BFS and DFS traversal algorithms on a graph. +# +# Run: ruby graph_traversal.rb + +class Graph + # Initialize an empty graph + def initialize + @adjacency_list = {} + end + + # Add a vertex to the graph + def add_vertex(vertex) + @adjacency_list[vertex] = [] unless @adjacency_list.key?(vertex) + end + + # Add an edge between two vertices + def add_edge(v1, v2) + # Ensure both vertices exist + add_vertex(v1) + add_vertex(v2) + + # Add the edge (undirected graph) + @adjacency_list[v1] << v2 + @adjacency_list[v2] << v1 + end + + # Get sorted neighbors for consistent output + def get_sorted_neighbors(vertex) + @adjacency_list[vertex].sort + end + + # Breadth-First Search traversal + def bfs(start) + return [] unless @adjacency_list.key?(start) + + visited = { start => true } + queue = [start] + result = [] + + puts "Starting BFS traversal from vertex #{start}" + + until queue.empty? + # Dequeue the first vertex + vertex = queue.shift + result << vertex + + puts "Visiting: #{vertex}" + puts "Queue: #{queue.inspect}" + puts "Visited so far: #{result.inspect}" + puts "------------------------------" + + # Pause for demonstration + sleep(0.5) # 500ms + + # Get sorted neighbors for consistent order + neighbors = get_sorted_neighbors(vertex) + + # Enqueue all unvisited neighbors + neighbors.each do |neighbor| + unless visited[neighbor] + visited[neighbor] = true + queue << neighbor + end + end + end + + result + end + + # Depth-First Search traversal (recursive) + def dfs_recursive(start) + return [] unless @adjacency_list.key?(start) + + visited = {} + result = [] + + puts "Starting recursive DFS traversal from vertex #{start}" + + dfs_helper(start, visited, result) + + result + end + + # Helper method for recursive DFS + def dfs_helper(vertex, visited, result) + # Mark as visited and add to result + visited[vertex] = true + result << vertex + + puts "Visiting: #{vertex}" + puts "Visited so far: #{result.inspect}" + puts "------------------------------" + + # Pause for demonstration + sleep(0.5) # 500ms + + # Get sorted neighbors for consistent order + neighbors = get_sorted_neighbors(vertex) + + # Recursively visit all unvisited neighbors + neighbors.each do |neighbor| + dfs_helper(neighbor, visited, result) unless visited[neighbor] + end + end + + # Depth-First Search traversal (iterative) + def dfs_iterative(start) + return [] unless @adjacency_list.key?(start) + + visited = {} + stack = [start] + result = [] + + puts "Starting iterative DFS traversal from vertex #{start}" + + until stack.empty? + # Pop the top vertex + vertex = stack.pop + + # If not visited, process it + unless visited[vertex] + visited[vertex] = true + result << vertex + + puts "Visiting: #{vertex}" + puts "Stack: #{stack.inspect}" + puts "Visited so far: #{result.inspect}" + puts "------------------------------" + + # Pause for demonstration + sleep(0.5) # 500ms + + # Get sorted neighbors in reverse order for stack + neighbors = get_sorted_neighbors(vertex).reverse + + # Push all unvisited neighbors onto the stack + neighbors.each do |neighbor| + stack << neighbor unless visited[neighbor] + end + end + end + + result + end + + # Print the graph structure + def visualize_graph + puts "\nGraph Structure:" + puts "------------------------------" + + # Sort vertices for consistent output + vertices = @adjacency_list.keys.sort + + vertices.each do |vertex| + neighbors = get_sorted_neighbors(vertex) + puts "#{vertex} -> #{neighbors.inspect}" + end + + puts "------------------------------" + end +end + +# Create a sample graph for demonstration +def create_sample_graph + g = Graph.new + + # Add edges to build this graph: + # A + # / \ + # B C + # / \ \ + # D E---F + + edges = [ + ["A", "B"], ["A", "C"], + ["B", "D"], ["B", "E"], + ["C", "F"], ["E", "F"] + ] + + edges.each do |v1, v2| + g.add_edge(v1, v2) + end + + g +end + +# Main execution +g = create_sample_graph +g.visualize_graph + +# Demonstrate BFS +puts "\n=== BFS Traversal ===" +bfs_result = g.bfs("A") +puts "BFS Result: #{bfs_result.inspect}" + +# Demonstrate recursive DFS +puts "\n=== DFS Traversal (Recursive) ===" +dfs_rec_result = g.dfs_recursive("A") +puts "DFS Recursive Result: #{dfs_rec_result.inspect}" + +# Demonstrate iterative DFS +puts "\n=== DFS Traversal (Iterative) ===" +dfs_iter_result = g.dfs_iterative("A") +puts "DFS Iterative Result: #{dfs_iter_result.inspect}" \ No newline at end of file diff --git a/snippets/algorithms/graph-traversal/graph_traversal.rs b/snippets/algorithms/graph-traversal/graph_traversal.rs new file mode 100644 index 0000000..d031df9 --- /dev/null +++ b/snippets/algorithms/graph-traversal/graph_traversal.rs @@ -0,0 +1,242 @@ +use std::collections::{HashMap, HashSet, VecDeque}; +use std::thread; +use std::time::Duration; + +/// Graph Traversal Algorithms in Rust +/// +/// This program demonstrates BFS and DFS traversal algorithms on a graph. +/// +/// Compile: rustc graph_traversal.rs +/// Run: ./graph_traversal + +/// A graph using adjacency list representation +struct Graph { + // Adjacency list representation + adjacency_list: HashMap>, +} + +impl Graph { + /// Creates a new empty graph + fn new() -> Self { + Graph { + adjacency_list: HashMap::new(), + } + } + + /// Adds a vertex to the graph + fn add_vertex(&mut self, vertex: &str) { + self.adjacency_list.entry(vertex.to_string()).or_insert(Vec::new()); + } + + /// Adds an edge between two vertices + fn add_edge(&mut self, v1: &str, v2: &str) { + // Ensure both vertices exist + self.add_vertex(v1); + self.add_vertex(v2); + + // Add the edge (undirected graph) + self.adjacency_list.get_mut(v1).unwrap().push(v2.to_string()); + self.adjacency_list.get_mut(v2).unwrap().push(v1.to_string()); + } + + /// Helper method to get sorted neighbors for consistent output + fn get_sorted_neighbors(&self, vertex: &str) -> Vec { + let mut neighbors = self.adjacency_list[vertex].clone(); + neighbors.sort(); + neighbors + } + + /// Performs a breadth-first search traversal starting from the given vertex + fn bfs(&self, start: &str) -> Vec { + if !self.adjacency_list.contains_key(start) { + return Vec::new(); + } + + let mut visited = HashSet::new(); + let mut queue = VecDeque::new(); + let mut result = Vec::new(); + + // Initialize with starting vertex + visited.insert(start.to_string()); + queue.push_back(start.to_string()); + + println!("Starting BFS traversal from vertex {}", start); + + while !queue.is_empty() { + // Dequeue the first vertex + let vertex = queue.pop_front().unwrap(); + result.push(vertex.clone()); + + println!("Visiting: {}", vertex); + println!("Queue: {:?}", queue); + println!("Visited so far: {:?}", result); + println!("------------------------------"); + + // Pause for demonstration + thread::sleep(Duration::from_millis(500)); + + // Get sorted neighbors for consistent order + let neighbors = self.get_sorted_neighbors(&vertex); + + // Enqueue all unvisited neighbors + for neighbor in neighbors { + if !visited.contains(&neighbor) { + visited.insert(neighbor.clone()); + queue.push_back(neighbor); + } + } + } + + result + } + + /// Performs a recursive depth-first search traversal starting from the given vertex + fn dfs_recursive(&self, start: &str) -> Vec { + if !self.adjacency_list.contains_key(start) { + return Vec::new(); + } + + let mut visited = HashSet::new(); + let mut result = Vec::new(); + + println!("Starting recursive DFS traversal from vertex {}", start); + + self.dfs_helper(start, &mut visited, &mut result); + + result + } + + /// Helper method for recursive DFS + fn dfs_helper(&self, vertex: &str, visited: &mut HashSet, result: &mut Vec) { + // Mark as visited and add to result + visited.insert(vertex.to_string()); + result.push(vertex.to_string()); + + println!("Visiting: {}", vertex); + println!("Visited so far: {:?}", result); + println!("------------------------------"); + + // Pause for demonstration + thread::sleep(Duration::from_millis(500)); + + // Get sorted neighbors for consistent order + let neighbors = self.get_sorted_neighbors(vertex); + + // Recursively visit all unvisited neighbors + for neighbor in neighbors { + if !visited.contains(&neighbor) { + self.dfs_helper(&neighbor, visited, result); + } + } + } + + /// Performs an iterative depth-first search traversal starting from the given vertex + fn dfs_iterative(&self, start: &str) -> Vec { + if !self.adjacency_list.contains_key(start) { + return Vec::new(); + } + + let mut visited = HashSet::new(); + let mut stack = Vec::new(); + let mut result = Vec::new(); + + // Initialize with starting vertex + stack.push(start.to_string()); + + println!("Starting iterative DFS traversal from vertex {}", start); + + while !stack.is_empty() { + // Pop the top vertex + let vertex = stack.pop().unwrap(); + + // If not visited, process it + if !visited.contains(&vertex) { + visited.insert(vertex.clone()); + result.push(vertex.clone()); + + println!("Visiting: {}", vertex); + println!("Stack: {:?}", stack); + println!("Visited so far: {:?}", result); + println!("------------------------------"); + + // Pause for demonstration + thread::sleep(Duration::from_millis(500)); + + // Get sorted neighbors in reverse order for stack + let mut neighbors = self.get_sorted_neighbors(&vertex); + neighbors.reverse(); + + // Push all unvisited neighbors onto the stack + for neighbor in neighbors { + if !visited.contains(&neighbor) { + stack.push(neighbor); + } + } + } + } + + result + } + + /// Prints a visualization of the graph structure + fn visualize_graph(&self) { + println!("\nGraph Structure:"); + println!("------------------------------"); + + // Sort vertices for consistent output + let mut vertices: Vec = self.adjacency_list.keys().cloned().collect(); + vertices.sort(); + + for vertex in vertices { + let neighbors = self.get_sorted_neighbors(&vertex); + println!("{} -> {:?}", vertex, neighbors); + } + + println!("------------------------------"); + } +} + +/// Creates a sample graph for demonstration +fn create_sample_graph() -> Graph { + let mut g = Graph::new(); + + // Add edges to build this graph: + // A + // / \ + // B C + // / \ \ + // D E---F + + let edges = [ + ("A", "B"), ("A", "C"), + ("B", "D"), ("B", "E"), + ("C", "F"), ("E", "F") + ]; + + for (v1, v2) in edges.iter() { + g.add_edge(v1, v2); + } + + g +} + +fn main() { + // Create a sample graph + let g = create_sample_graph(); + g.visualize_graph(); + + // Demonstrate BFS + println!("\n=== BFS Traversal ==="); + let bfs_result = g.bfs("A"); + println!("BFS Result: {:?}", bfs_result); + + // Demonstrate recursive DFS + println!("\n=== DFS Traversal (Recursive) ==="); + let dfs_rec_result = g.dfs_recursive("A"); + println!("DFS Recursive Result: {:?}", dfs_rec_result); + + // Demonstrate iterative DFS + println!("\n=== DFS Traversal (Iterative) ==="); + let dfs_iter_result = g.dfs_iterative("A"); + println!("DFS Iterative Result: {:?}", dfs_iter_result); +} \ No newline at end of file diff --git a/snippets/algorithms/init.txt b/snippets/algorithms/init.txt new file mode 100644 index 0000000..e69de29 diff --git a/snippets/databases/.env.example b/snippets/databases/.env.example new file mode 100644 index 0000000..46b59e9 --- /dev/null +++ b/snippets/databases/.env.example @@ -0,0 +1,32 @@ +# Database configuration example file +# Copy this file to .env and fill in your actual values + +# SQLite Configuration +SQLITE_DB_PATH=:memory: + +# PostgreSQL Configuration +PG_HOST=localhost +PG_DATABASE=mydb +PG_USER=postgres +PG_PASSWORD=your_secure_password + +# MySQL Configuration +MYSQL_HOST=localhost +MYSQL_DATABASE=mydb +MYSQL_USER=root +MYSQL_PASSWORD=your_secure_password + +# SQL Server Configuration +SQLSERVER_CONNECTION_STRING=Server=localhost;Database=TestDB;User Id=sa;Password=your_secure_password; + +# Other database connection strings +POSTGRES_CONNECTION_STRING=Host=localhost;Database=testdb;Username=postgres;Password=your_secure_password; +MYSQL_CONNECTION_STRING=Server=localhost;Database=testdb;Uid=root;Pwd=your_secure_password; +DAPPER_CONNECTION_STRING=Data Source=:memory: + +# SQLAlchemy URL for Python ORM +# Format examples: +# SQLite: sqlite:///path/to/database.db +# PostgreSQL: postgresql://user:password@localhost/dbname +# MySQL: mysql://user:password@localhost/dbname +SQLALCHEMY_DATABASE_URL=sqlite:///:memory: \ No newline at end of file diff --git a/snippets/databases/README.md b/snippets/databases/README.md new file mode 100644 index 0000000..fb0aeed --- /dev/null +++ b/snippets/databases/README.md @@ -0,0 +1,186 @@ +# Database Code Examples + +This directory contains code examples for working with various relational databases in different programming languages. + +## Contents + +- `sql_examples.py` - Python examples for SQLite, PostgreSQL, MySQL, and SQLAlchemy ORM +- `relational_db_examples.cs` - C# examples for SQLite, SQL Server, MySQL, PostgreSQL, and Dapper ORM + +## Setup Instructions + +### Environment Variables + +For security reasons, all database connection credentials are loaded from environment variables. Follow these steps to set up your environment: + +1. Copy the example environment file to create your own `.env` file: + ```bash + cp envv.example .env + ``` + +2. Edit the `.env` file with your actual database credentials: + ``` + # Example for PostgreSQL + PG_HOST=localhost + PG_DATABASE=yourdb + PG_USER=yourusername + PG_PASSWORD=yourpassword + ``` + +3. Make sure your `.env` file is included in `.gitignore` to prevent committing sensitive information. + +### Python Setup + +To run the Python examples: + +1. Install required dependencies: + ```bash + pip install python-dotenv + + # For SQLite (built into Python) + # No additional installation needed + + # For PostgreSQL + pip install psycopg2-binary + + # For MySQL + pip install mysql-connector-python + + # For SQLAlchemy ORM + pip install sqlalchemy + ``` + +2. Run the examples: + ```bash + python sql_examples.py + ``` + +### C# Setup + +To run the C# examples: + +1. Install required NuGet packages: + ```bash + # For SQLite + dotnet add package Microsoft.Data.Sqlite + + # For SQL Server + dotnet add package Microsoft.Data.SqlClient + + # For MySQL + dotnet add package MySql.Data + + # For PostgreSQL + dotnet add package Npgsql + + # For Dapper ORM + dotnet add package Dapper + ``` + +2. Build and run the examples: + ```bash + dotnet build + dotnet run + ``` + +## Usage Examples + +### Python SQLite Example + +```python +import sqlite3 +from dotenv import load_dotenv +import os + +# Load environment variables +load_dotenv() + +# Get database path from environment variable +db_path = os.environ.get("SQLITE_DB_PATH", ":memory:") + +# Connect to SQLite database +conn = sqlite3.connect(db_path) +cursor = conn.cursor() + +# Create a table +cursor.execute(''' +CREATE TABLE IF NOT EXISTS users ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT UNIQUE NOT NULL +) +''') + +# Insert data +cursor.execute('INSERT INTO users (name, email) VALUES (?, ?)', + ('John Doe', 'john@example.com')) +conn.commit() + +# Query data +cursor.execute('SELECT * FROM users') +print(cursor.fetchall()) + +# Close connection +conn.close() +``` + +### C# SQLite Example + +```csharp +using System; +using Microsoft.Data.Sqlite; + +// Get connection string from environment variable +string connectionString = Environment.GetEnvironmentVariable("SQLITE_CONNECTION_STRING") + ?? "Data Source=:memory:"; + +using (var connection = new SqliteConnection(connectionString)) +{ + connection.Open(); + + // Create a table + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + CREATE TABLE IF NOT EXISTS users ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT NOT NULL UNIQUE + )"; + command.ExecuteNonQuery(); + } + + // Insert data + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO users (name, email) + VALUES (@name, @email)"; + command.Parameters.AddWithValue("@name", "Jane Smith"); + command.Parameters.AddWithValue("@email", "jane@example.com"); + command.ExecuteNonQuery(); + } + + // Query data + using (var command = connection.CreateCommand()) + { + command.CommandText = "SELECT * FROM users"; + using (var reader = command.ExecuteReader()) + { + while (reader.Read()) + { + Console.WriteLine($"ID: {reader.GetInt32(0)}, Name: {reader.GetString(1)}, Email: {reader.GetString(2)}"); + } + } + } +} +``` + +## Security Best Practices + +1. Never hardcode database credentials in your source code +2. Always use parameterized queries to prevent SQL injection +3. Store connection strings and credentials in environment variables or a secure configuration system +4. Use the principle of least privilege for database users +5. Encrypt sensitive data before storing it in the database +6. Regularly update database drivers and libraries to patch security vulnerabilities \ No newline at end of file diff --git a/snippets/databases/README_vi.md b/snippets/databases/README_vi.md new file mode 100644 index 0000000..0ea5b09 --- /dev/null +++ b/snippets/databases/README_vi.md @@ -0,0 +1,186 @@ +# Ví Dụ Mã Nguồn Cơ Sở Dữ Liệu + +Thư mục này chứa các ví dụ mã nguồn để làm việc với nhiều cơ sở dữ liệu quan hệ khác nhau trong các ngôn ngữ lập trình khác nhau. + +## Nội Dung + +- `sql_examples.py` - Ví dụ Python cho SQLite, PostgreSQL, MySQL, và SQLAlchemy ORM +- `relational_db_examples.cs` - Ví dụ C# cho SQLite, SQL Server, MySQL, PostgreSQL, và Dapper ORM + +## Hướng Dẫn Cài Đặt + +### Biến Môi Trường + +Vì lý do bảo mật, tất cả thông tin đăng nhập cơ sở dữ liệu được tải từ biến môi trường. Làm theo các bước sau để thiết lập môi trường của bạn: + +1. Sao chép tệp môi trường mẫu để tạo tệp `.env` của riêng bạn: + ```bash + cp envv.example .env + ``` + +2. Chỉnh sửa tệp `.env` với thông tin đăng nhập cơ sở dữ liệu thực tế của bạn: + ``` + # Ví dụ cho PostgreSQL + PG_HOST=localhost + PG_DATABASE=yourdb + PG_USER=yourusername + PG_PASSWORD=yourpassword + ``` + +3. Đảm bảo tệp `.env` của bạn được bao gồm trong `.gitignore` để tránh commit thông tin nhạy cảm. + +### Cài Đặt Python + +Để chạy các ví dụ Python: + +1. Cài đặt các gói phụ thuộc cần thiết: + ```bash + pip install python-dotenv + + # Cho SQLite (đã tích hợp sẵn trong Python) + # Không cần cài đặt thêm + + # Cho PostgreSQL + pip install psycopg2-binary + + # Cho MySQL + pip install mysql-connector-python + + # Cho SQLAlchemy ORM + pip install sqlalchemy + ``` + +2. Chạy các ví dụ: + ```bash + python sql_examples.py + ``` + +### Cài Đặt C# + +Để chạy các ví dụ C#: + +1. Cài đặt các gói NuGet cần thiết: + ```bash + # Cho SQLite + dotnet add package Microsoft.Data.Sqlite + + # Cho SQL Server + dotnet add package Microsoft.Data.SqlClient + + # Cho MySQL + dotnet add package MySql.Data + + # Cho PostgreSQL + dotnet add package Npgsql + + # Cho Dapper ORM + dotnet add package Dapper + ``` + +2. Biên dịch và chạy các ví dụ: + ```bash + dotnet build + dotnet run + ``` + +## Ví Dụ Sử Dụng + +### Python SQLite Example + +```python +import sqlite3 +from dotenv import load_dotenv +import os + +# Load environment variables +load_dotenv() + +# Get database path from environment variable +db_path = os.environ.get("SQLITE_DB_PATH", ":memory:") + +# Connect to SQLite database +conn = sqlite3.connect(db_path) +cursor = conn.cursor() + +# Create a table +cursor.execute(''' +CREATE TABLE IF NOT EXISTS users ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT UNIQUE NOT NULL +) +''') + +# Insert data +cursor.execute('INSERT INTO users (name, email) VALUES (?, ?)', + ('John Doe', 'john@example.com')) +conn.commit() + +# Query data +cursor.execute('SELECT * FROM users') +print(cursor.fetchall()) + +# Close connection +conn.close() +``` + +### C# SQLite Example + +```csharp +using System; +using Microsoft.Data.Sqlite; + +// Get connection string from environment variable +string connectionString = Environment.GetEnvironmentVariable("SQLITE_CONNECTION_STRING") + ?? "Data Source=:memory:"; + +using (var connection = new SqliteConnection(connectionString)) +{ + connection.Open(); + + // Create a table + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + CREATE TABLE IF NOT EXISTS users ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT NOT NULL UNIQUE + )"; + command.ExecuteNonQuery(); + } + + // Insert data + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO users (name, email) + VALUES (@name, @email)"; + command.Parameters.AddWithValue("@name", "Jane Smith"); + command.Parameters.AddWithValue("@email", "jane@example.com"); + command.ExecuteNonQuery(); + } + + // Query data + using (var command = connection.CreateCommand()) + { + command.CommandText = "SELECT * FROM users"; + using (var reader = command.ExecuteReader()) + { + while (reader.Read()) + { + Console.WriteLine($"ID: {reader.GetInt32(0)}, Name: {reader.GetString(1)}, Email: {reader.GetString(2)}"); + } + } + } +} +``` + +## Các Phương Pháp Tốt Nhất về Bảo Mật + +1. Không bao giờ mã hóa cứng thông tin đăng nhập cơ sở dữ liệu trong mã nguồn của bạn +2. Luôn sử dụng truy vấn có tham số để ngăn chặn SQL injection +3. Lưu trữ chuỗi kết nối và thông tin đăng nhập trong biến môi trường hoặc hệ thống cấu hình bảo mật +4. Áp dụng nguyên tắc đặc quyền tối thiểu cho người dùng cơ sở dữ liệu +5. Mã hóa dữ liệu nhạy cảm trước khi lưu trữ trong cơ sở dữ liệu +6. Thường xuyên cập nhật trình điều khiển và thư viện cơ sở dữ liệu để vá các lỗ hổng bảo mật \ No newline at end of file diff --git a/snippets/databases/relational_db_examples.cs b/snippets/databases/relational_db_examples.cs new file mode 100644 index 0000000..062a3e6 --- /dev/null +++ b/snippets/databases/relational_db_examples.cs @@ -0,0 +1,829 @@ +using System; +using System.Data; +using System.Collections.Generic; +using System.Threading.Tasks; +// Requires NuGet packages: +// Microsoft.Data.SqlClient +// Microsoft.Data.Sqlite +// MySql.Data +// Npgsql +// Dapper +// Microsoft.Extensions.Configuration.EnvironmentVariables (for .NET environment variables) + +namespace RelationalDatabaseExamples +{ + /// + /// Examples of working with relational databases in C# + /// + class Program + { + // Configuration for environment variables + private static readonly EnvironmentVariableManager _env = new EnvironmentVariableManager(); + + static async Task Main(string[] args) + { + Console.WriteLine("C# Relational Database Examples"); + Console.WriteLine("==============================="); + + try + { + // SQLite example (works without additional setup) + await SQLiteExample(); + + // The following examples require database servers to be running + // Uncomment them if you have the necessary databases set up + + // await SqlServerExample(); + // await MySqlExample(); + // await PostgreSqlExample(); + // await DapperExample(); + + Console.WriteLine("\nAll examples completed successfully."); + } + catch (Exception ex) + { + Console.WriteLine($"Error: {ex.Message}"); + } + } + + /// + /// Example using SQLite + /// + static async Task SQLiteExample() + { + Console.WriteLine("\n=== SQLite Example ==="); + + // Make sure you have the Microsoft.Data.Sqlite NuGet package installed + var connectionString = _env.GetValue("SQLITE_CONNECTION_STRING", "Data Source=:memory:"); + + using (var connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString)) + { + await connection.OpenAsync(); + Console.WriteLine("Connected to SQLite database"); + + // Create a table + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + CREATE TABLE Employees ( + Id INTEGER PRIMARY KEY, + Name TEXT NOT NULL, + Department TEXT NOT NULL, + Salary REAL, + HireDate TEXT + )"; + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Created Employees table"); + } + + // Insert data using parameters + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO Employees (Name, Department, Salary, HireDate) + VALUES (@name, @department, @salary, @hireDate)"; + + command.Parameters.AddWithValue("@name", "John Smith"); + command.Parameters.AddWithValue("@department", "Engineering"); + command.Parameters.AddWithValue("@salary", 85000.00); + command.Parameters.AddWithValue("@hireDate", DateTime.Now.ToString("yyyy-MM-dd")); + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Inserted employee: John Smith"); + + // Insert another employee + command.Parameters.Clear(); + command.Parameters.AddWithValue("@name", "Jane Doe"); + command.Parameters.AddWithValue("@department", "Marketing"); + command.Parameters.AddWithValue("@salary", 75000.00); + command.Parameters.AddWithValue("@hireDate", DateTime.Now.AddDays(-90).ToString("yyyy-MM-dd")); + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Inserted employee: Jane Doe"); + + // One more employee + command.Parameters.Clear(); + command.Parameters.AddWithValue("@name", "Bob Johnson"); + command.Parameters.AddWithValue("@department", "Engineering"); + command.Parameters.AddWithValue("@salary", 82000.00); + command.Parameters.AddWithValue("@hireDate", DateTime.Now.AddDays(-180).ToString("yyyy-MM-dd")); + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Inserted employee: Bob Johnson"); + } + + // Query all employees + Console.WriteLine("\nAll employees:"); + using (var command = connection.CreateCommand()) + { + command.CommandText = "SELECT Id, Name, Department, Salary FROM Employees"; + + using (var reader = await command.ExecuteReaderAsync()) + { + while (await reader.ReadAsync()) + { + Console.WriteLine($"ID: {reader.GetInt32(0)}, Name: {reader.GetString(1)}, " + + $"Department: {reader.GetString(2)}, Salary: ${reader.GetDouble(3):N2}"); + } + } + } + + // Filtered query with parameters + Console.WriteLine("\nEngineering department employees:"); + using (var command = connection.CreateCommand()) + { + command.CommandText = "SELECT Name, Salary FROM Employees WHERE Department = @department"; + command.Parameters.AddWithValue("@department", "Engineering"); + + using (var reader = await command.ExecuteReaderAsync()) + { + while (await reader.ReadAsync()) + { + Console.WriteLine($"{reader.GetString(0)}: ${reader.GetDouble(1):N2}"); + } + } + } + + // Aggregate query + Console.WriteLine("\nDepartment statistics:"); + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + SELECT Department, + COUNT(*) as EmployeeCount, + AVG(Salary) as AvgSalary, + SUM(Salary) as TotalSalary + FROM Employees + GROUP BY Department"; + + using (var reader = await command.ExecuteReaderAsync()) + { + while (await reader.ReadAsync()) + { + Console.WriteLine($"{reader.GetString(0)}: " + + $"{reader.GetInt32(1)} employees, " + + $"Avg: ${reader.GetDouble(2):N2}, " + + $"Total: ${reader.GetDouble(3):N2}"); + } + } + } + + // Transaction example + await using (var transaction = connection.BeginTransaction()) + { + try + { + // Update salary in a transaction + using (var command = connection.CreateCommand()) + { + command.Transaction = transaction; + command.CommandText = "UPDATE Employees SET Salary = Salary * 1.1 WHERE Department = @department"; + command.Parameters.AddWithValue("@department", "Engineering"); + + var rowsAffected = await command.ExecuteNonQueryAsync(); + Console.WriteLine($"\nGave 10% raise to {rowsAffected} engineering employees"); + } + + // Verify the changes + using (var command = connection.CreateCommand()) + { + command.Transaction = transaction; + command.CommandText = "SELECT Name, Salary FROM Employees WHERE Department = @department"; + command.Parameters.AddWithValue("@department", "Engineering"); + + Console.WriteLine("Updated engineering salaries:"); + using (var reader = await command.ExecuteReaderAsync()) + { + while (await reader.ReadAsync()) + { + Console.WriteLine($"{reader.GetString(0)}: ${reader.GetDouble(1):N2}"); + } + } + } + + // Commit the transaction + await transaction.CommitAsync(); + Console.WriteLine("Transaction committed"); + } + catch (Exception ex) + { + await transaction.RollbackAsync(); + Console.WriteLine($"Transaction rolled back: {ex.Message}"); + } + } + } + } + + /// + /// Example using SQL Server + /// + static async Task SqlServerExample() + { + Console.WriteLine("\n=== SQL Server Example ==="); + Console.WriteLine("To run this example, you need SQL Server and the Microsoft.Data.SqlClient NuGet package."); + + // Connection string for SQL Server from environment variables + var connectionString = _env.GetValue("SQLSERVER_CONNECTION_STRING", + "Server=localhost;Database=TestDB;Trusted_Connection=True;"); + + Console.WriteLine($"Using connection info from environment: {GetSanitizedConnectionString(connectionString)}"); + + using (var connection = new Microsoft.Data.SqlClient.SqlConnection(connectionString)) + { + await connection.OpenAsync(); + Console.WriteLine("Connected to SQL Server"); + + // Create a table with SQL Server specific features + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = 'Products') + BEGIN + CREATE TABLE Products ( + Id INT IDENTITY(1,1) PRIMARY KEY, + Name NVARCHAR(100) NOT NULL, + Description NVARCHAR(MAX), + Price DECIMAL(10,2) NOT NULL, + Category NVARCHAR(50), + CreatedAt DATETIME2 DEFAULT GETDATE(), + UpdatedAt DATETIME2, + IsActive BIT DEFAULT 1 + ); + + CREATE INDEX IX_Products_Category ON Products(Category); + END"; + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Created Products table"); + } + + // Insert with output parameter to get the identity value + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO Products (Name, Description, Price, Category) + OUTPUT INSERTED.Id + VALUES (@name, @description, @price, @category)"; + + command.Parameters.AddWithValue("@name", "Laptop"); + command.Parameters.AddWithValue("@description", "High-performance laptop"); + command.Parameters.AddWithValue("@price", 1299.99); + command.Parameters.AddWithValue("@category", "Electronics"); + + var productId = (int)await command.ExecuteScalarAsync(); + Console.WriteLine($"Inserted product with ID: {productId}"); + } + + // SQL Server specific features: CTE, ROW_NUMBER + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + WITH RankedProducts AS ( + SELECT + Name, + Price, + Category, + ROW_NUMBER() OVER (PARTITION BY Category ORDER BY Price DESC) AS PriceRank + FROM + Products + ) + SELECT Name, Price, Category, PriceRank + FROM RankedProducts + WHERE PriceRank <= 3"; + + using (var reader = await command.ExecuteReaderAsync()) + { + Console.WriteLine("\nTop 3 most expensive products per category:"); + while (await reader.ReadAsync()) + { + Console.WriteLine($"{reader.GetString(0)} - ${reader.GetDecimal(1):N2} - " + + $"{reader.GetString(2)} (Rank: {reader.GetInt64(3)})"); + } + } + } + + // Using stored procedure + using (var command = connection.CreateCommand()) + { + // First create the stored procedure + command.CommandText = @" + IF NOT EXISTS (SELECT * FROM sys.procedures WHERE name = 'GetProductsByCategory') + BEGIN + EXEC(' + CREATE PROCEDURE GetProductsByCategory + @CategoryName NVARCHAR(50), + @MinPrice DECIMAL(10,2) = 0 + AS + BEGIN + SELECT Id, Name, Price + FROM Products + WHERE Category = @CategoryName + AND Price >= @MinPrice + ORDER BY Price DESC; + END + ') + END"; + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Created stored procedure"); + + // Use the stored procedure + command.CommandText = "GetProductsByCategory"; + command.CommandType = CommandType.StoredProcedure; + + command.Parameters.Clear(); + command.Parameters.AddWithValue("@CategoryName", "Electronics"); + command.Parameters.AddWithValue("@MinPrice", 500); + + using (var reader = await command.ExecuteReaderAsync()) + { + Console.WriteLine("\nElectronics products over $500:"); + while (await reader.ReadAsync()) + { + Console.WriteLine($"ID: {reader.GetInt32(0)}, Name: {reader.GetString(1)}, " + + $"Price: ${reader.GetDecimal(2):N2}"); + } + } + } + } + } + + /// + /// Example using MySQL + /// + static async Task MySqlExample() + { + Console.WriteLine("\n=== MySQL Example ==="); + Console.WriteLine("To run this example, you need MySQL and the MySql.Data NuGet package."); + + // Connection string for MySQL from environment variables + var connectionString = _env.GetValue("MYSQL_CONNECTION_STRING", + "Server=localhost;Database=testdb;Uid=root;Pwd=password;"); + + Console.WriteLine($"Using connection info from environment: {GetSanitizedConnectionString(connectionString)}"); + + using (var connection = new MySql.Data.MySqlClient.MySqlConnection(connectionString)) + { + await connection.OpenAsync(); + Console.WriteLine("Connected to MySQL"); + + // Create a table with MySQL specific features + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + CREATE TABLE IF NOT EXISTS Orders ( + id INT AUTO_INCREMENT PRIMARY KEY, + customer_name VARCHAR(100) NOT NULL, + total DECIMAL(10,2) NOT NULL, + status ENUM('pending', 'shipped', 'delivered') NOT NULL, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + INDEX idx_status (status), + INDEX idx_created_at (created_at) + ) ENGINE=InnoDB"; + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Created Orders table"); + } + + // Insert with MySQL-specific AUTO_INCREMENT handling + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO Orders (customer_name, total, status) + VALUES (@customerName, @total, @status)"; + + command.Parameters.AddWithValue("@customerName", "John Doe"); + command.Parameters.AddWithValue("@total", 123.45); + command.Parameters.AddWithValue("@status", "pending"); + + await command.ExecuteNonQueryAsync(); + Console.WriteLine($"Inserted order, ID: {command.LastInsertedId}"); + } + + // MySQL specific functions + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + SELECT + id, + customer_name, + total, + status, + DATE_FORMAT(created_at, '%Y-%m-%d %H:%i:%s') AS formatted_date, + DATEDIFF(NOW(), created_at) AS days_since_creation + FROM + Orders + WHERE + created_at > DATE_SUB(NOW(), INTERVAL 7 DAY)"; + + using (var reader = await command.ExecuteReaderAsync()) + { + Console.WriteLine("\nRecent orders:"); + while (await reader.ReadAsync()) + { + Console.WriteLine($"ID: {reader.GetInt32(0)}, " + + $"Customer: {reader.GetString(1)}, " + + $"Total: ${reader.GetDecimal(2):N2}, " + + $"Status: {reader.GetString(3)}, " + + $"Created: {reader.GetString(4)} " + + $"({reader.GetInt32(5)} days ago)"); + } + } + } + } + } + + /// + /// Example using PostgreSQL + /// + static async Task PostgreSqlExample() + { + Console.WriteLine("\n=== PostgreSQL Example ==="); + Console.WriteLine("To run this example, you need PostgreSQL and the Npgsql NuGet package."); + + // Connection string for PostgreSQL from environment variables + var connectionString = _env.GetValue("POSTGRES_CONNECTION_STRING", + "Host=localhost;Database=testdb;Username=postgres;Password=password"); + + Console.WriteLine($"Using connection info from environment: {GetSanitizedConnectionString(connectionString)}"); + + using (var connection = new Npgsql.NpgsqlConnection(connectionString)) + { + await connection.OpenAsync(); + Console.WriteLine("Connected to PostgreSQL"); + + // Create a table with PostgreSQL-specific features + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + CREATE TABLE IF NOT EXISTS products ( + id SERIAL PRIMARY KEY, + name VARCHAR(100) NOT NULL, + description TEXT, + price DECIMAL(10,2) NOT NULL, + created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + tags TEXT[], + metadata JSONB + )"; + + await command.ExecuteNonQueryAsync(); + Console.WriteLine("Created products table"); + } + + // Insert with PostgreSQL-specific data types + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + INSERT INTO products (name, description, price, tags, metadata) + VALUES (@name, @description, @price, @tags, @metadata) + RETURNING id"; + + command.Parameters.AddWithValue("@name", "Laptop"); + command.Parameters.AddWithValue("@description", "High-performance laptop"); + command.Parameters.AddWithValue("@price", 999.99); + command.Parameters.AddWithValue("@tags", new string[] { "electronics", "computers" }); + command.Parameters.AddWithValue("@metadata", "{""brand"": ""TechBrand"", ""warranty"": ""2 years"", ""specs"": {""cpu"": ""i7"", ""ram"": ""16GB""}}"); + + var productId = (int)await command.ExecuteScalarAsync(); + Console.WriteLine($"Inserted product with ID: {productId}"); + } + + // PostgreSQL-specific features: JSONB, arrays + using (var command = connection.CreateCommand()) + { + command.CommandText = @" + SELECT + name, + price, + metadata->>'brand' AS brand, + metadata->'specs'->>'cpu' AS cpu, + array_length(tags, 1) AS tag_count, + extract(year from created_at) AS year + FROM + products + WHERE + 'electronics' = ANY(tags)"; + + using (var reader = await command.ExecuteReaderAsync()) + { + Console.WriteLine("\nElectronics products:"); + while (await reader.ReadAsync()) + { + Console.WriteLine($"{reader.GetString(0)} - ${reader.GetDecimal(1):N2} - " + + $"Brand: {reader.GetString(2)}, CPU: {reader.GetString(3)}, " + + $"Tag count: {reader.GetInt32(4)}, Year: {reader.GetDouble(5)}"); + } + } + } + } + } + + /// + /// Example using Dapper micro-ORM + /// + static async Task DapperExample() + { + Console.WriteLine("\n=== Dapper Example ==="); + Console.WriteLine("To run this example, you need the Dapper NuGet package and a database connection."); + + // Connection string from environment variables + var connectionString = _env.GetValue("DAPPER_CONNECTION_STRING", "Data Source=:memory:"); + + using (var connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString)) + { + await connection.OpenAsync(); + Console.WriteLine("Connected to SQLite for Dapper example"); + + // Set up database + await connection.ExecuteAsync(@" + CREATE TABLE Customers ( + Id INTEGER PRIMARY KEY, + Name TEXT NOT NULL, + Email TEXT NOT NULL + ); + + CREATE TABLE Orders ( + Id INTEGER PRIMARY KEY, + CustomerId INTEGER NOT NULL, + Amount REAL NOT NULL, + OrderDate TEXT NOT NULL, + FOREIGN KEY (CustomerId) REFERENCES Customers (Id) + ); + + CREATE TABLE OrderItems ( + Id INTEGER PRIMARY KEY, + OrderId INTEGER NOT NULL, + ProductName TEXT NOT NULL, + Quantity INTEGER NOT NULL, + UnitPrice REAL NOT NULL, + FOREIGN KEY (OrderId) REFERENCES Orders (Id) + ); + "); + + // Insert customers + var customerIds = await connection.ExecuteAsync(@" + INSERT INTO Customers (Name, Email) VALUES + (@Name, @Email)", + new[] { + new { Name = "Alice Smith", Email = "alice@example.com" }, + new { Name = "Bob Jones", Email = "bob@example.com" } + }); + + Console.WriteLine($"Inserted {customerIds} customers"); + + // Insert orders + var orderDate = DateTime.Now; + var order1Id = await connection.QuerySingleAsync(@" + INSERT INTO Orders (CustomerId, Amount, OrderDate) + VALUES (@CustomerId, @Amount, @OrderDate) + RETURNING Id", + new { CustomerId = 1, Amount = 125.50, OrderDate = orderDate.ToString("yyyy-MM-dd") }); + + // Insert order items + await connection.ExecuteAsync(@" + INSERT INTO OrderItems (OrderId, ProductName, Quantity, UnitPrice) + VALUES (@OrderId, @ProductName, @Quantity, @UnitPrice)", + new[] { + new { OrderId = order1Id, ProductName = "Keyboard", Quantity = 1, UnitPrice = 75.50 }, + new { OrderId = order1Id, ProductName = "Mouse", Quantity = 1, UnitPrice = 50.00 } + }); + + // Query with Dapper + var customers = await connection.QueryAsync("SELECT * FROM Customers"); + + Console.WriteLine("\nAll customers:"); + foreach (var customer in customers) + { + Console.WriteLine($"ID: {customer.Id}, Name: {customer.Name}, Email: {customer.Email}"); + } + + // Query with join and multi-mapping + Console.WriteLine("\nOrders with customer info:"); + var orders = await connection.QueryAsync( + @"SELECT o.Id, o.Amount, o.OrderDate, c.Id, c.Name, c.Email + FROM Orders o + JOIN Customers c ON o.CustomerId = c.Id", + (order, customer) => { + order.Customer = customer; + return order; + }, + splitOn: "Id" + ); + + foreach (var order in orders) + { + Console.WriteLine($"Order #{order.Id} - ${order.Amount:N2} on {order.OrderDate} " + + $"by {order.Customer.Name} ({order.Customer.Email})"); + } + + // Query order details with complex mapping + Console.WriteLine("\nOrder details:"); + var orderWithItems = await connection.QueryAsync( + @"SELECT o.Id, o.Amount, o.OrderDate, i.Id, i.ProductName, i.Quantity, i.UnitPrice + FROM Orders o + JOIN OrderItems i ON o.Id = i.OrderId + WHERE o.Id = @OrderId", + (order, item) => { + if (order.Items == null) + order.Items = new List(); + order.Items.Add(item); + return order; + }, + new { OrderId = order1Id }, + splitOn: "Id" + ); + + var orderDetail = orderWithItems.GroupBy(o => o.Id).Select(g => { + var order = g.First(); + order.Items = g.Select(o => o.Items.Single()).ToList(); + return order; + }).First(); + + Console.WriteLine($"Order #{orderDetail.Id} - ${orderDetail.Amount:N2} on {orderDetail.OrderDate}"); + foreach (var item in orderDetail.Items) + { + Console.WriteLine($" {item.ProductName}: {item.Quantity} x ${item.UnitPrice:N2} = ${item.Quantity * item.UnitPrice:N2}"); + } + + // Execute scalar + var totalSales = await connection.ExecuteScalarAsync( + "SELECT SUM(Amount) FROM Orders"); + + Console.WriteLine($"\nTotal sales: ${totalSales:N2}"); + } + } + + /// + /// Sanitizes a connection string by hiding the password + /// + private static string GetSanitizedConnectionString(string connectionString) + { + // Simple sanitization to hide password/credentials + if (string.IsNullOrEmpty(connectionString)) + return connectionString; + + // Handle different formats for different database providers + return connectionString + .Replace(GetPasswordPart(connectionString, "Password="), "Password=*****") + .Replace(GetPasswordPart(connectionString, "Pwd="), "Pwd=*****") + .Replace(GetPasswordPart(connectionString, "password="), "password=*****"); + } + + private static string GetPasswordPart(string connectionString, string passwordPrefix) + { + int pwdIndex = connectionString.IndexOf(passwordPrefix, StringComparison.OrdinalIgnoreCase); + if (pwdIndex < 0) + return string.Empty; + + int startIndex = pwdIndex + passwordPrefix.Length; + int endIndex = connectionString.IndexOf(';', startIndex); + if (endIndex < 0) + endIndex = connectionString.Length; + + return connectionString.Substring(pwdIndex, endIndex - pwdIndex); + } + + // Model classes for Dapper example + public class Customer + { + public int Id { get; set; } + public string Name { get; set; } + public string Email { get; set; } + public List Orders { get; set; } + } + + public class Order + { + public int Id { get; set; } + public int CustomerId { get; set; } + public double Amount { get; set; } + public string OrderDate { get; set; } + public Customer Customer { get; set; } + public List Items { get; set; } + } + + public class OrderItem + { + public int Id { get; set; } + public int OrderId { get; set; } + public string ProductName { get; set; } + public int Quantity { get; set; } + public double UnitPrice { get; set; } + } + } + + /// + /// Helper class to manage environment variables with fallback values + /// + public class EnvironmentVariableManager + { + /// + /// Gets a value from environment variables with a fallback default + /// + public string GetValue(string key, string defaultValue) + { + var value = Environment.GetEnvironmentVariable(key); + return string.IsNullOrWhiteSpace(value) ? defaultValue : value; + } + } +} + +// Extensions method for Dapper (to simulate Dapper behavior) +public static class DapperExtensions +{ + public static Task ExecuteAsync(this IDbConnection connection, string sql, object param = null) + { + // Simplified for the example + using (var command = connection.CreateCommand()) + { + command.CommandText = sql; + if (param is IEnumerable enumerable) + { + int totalRows = 0; + foreach (var p in enumerable) + { + // This is highly simplified and doesn't handle parameters correctly + totalRows++; + } + return Task.FromResult(totalRows); + } + + return Task.FromResult(command.ExecuteNonQuery()); + } + } + + public static Task QuerySingleAsync(this IDbConnection connection, string sql, object param = null) + { + // Simplified for the example + using (var command = connection.CreateCommand()) + { + command.CommandText = sql; + // This is highly simplified + return Task.FromResult((T)(object)1); + } + } + + public static Task> QueryAsync(this IDbConnection connection, string sql, object param = null) + { + // Simplified for the example + if (typeof(T) == typeof(Customer)) + { + var customers = new List + { + new Customer { Id = 1, Name = "Alice Smith", Email = "alice@example.com" }, + new Customer { Id = 2, Name = "Bob Jones", Email = "bob@example.com" } + }; + return Task.FromResult((IEnumerable)(object)customers); + } + + return Task.FromResult((IEnumerable)new List()); + } + + public static Task> QueryAsync( + this IDbConnection connection, + string sql, + Func map, + object param = null, + string splitOn = "Id") + { + // Simplified for the example + if (typeof(T1) == typeof(Order) && typeof(T2) == typeof(Customer)) + { + var customer = new Customer { Id = 1, Name = "Alice Smith", Email = "alice@example.com" }; + var order = new Order { Id = 1, CustomerId = 1, Amount = 125.50, OrderDate = DateTime.Now.ToString("yyyy-MM-dd") }; + + var result = new List + { + map((T1)(object)order, (T2)(object)customer) + }; + + return Task.FromResult((IEnumerable)result); + } + else if (typeof(T1) == typeof(Order) && typeof(T2) == typeof(OrderItem)) + { + var order = new Order { Id = 1, CustomerId = 1, Amount = 125.50, OrderDate = DateTime.Now.ToString("yyyy-MM-dd") }; + var items = new List + { + new OrderItem { Id = 1, OrderId = 1, ProductName = "Keyboard", Quantity = 1, UnitPrice = 75.50 }, + new OrderItem { Id = 2, OrderId = 1, ProductName = "Mouse", Quantity = 1, UnitPrice = 50.00 } + }; + + var result = new List(); + foreach (var item in items) + { + result.Add(map((T1)(object)order, (T2)(object)item)); + } + + return Task.FromResult((IEnumerable)result); + } + + return Task.FromResult((IEnumerable)new List()); + } + + public static Task ExecuteScalarAsync(this IDbConnection connection, string sql, object param = null) + { + // Simplified for the example + return Task.FromResult((T)(object)125.50); + } +} \ No newline at end of file diff --git a/snippets/databases/sql_examples.py b/snippets/databases/sql_examples.py new file mode 100644 index 0000000..a6f3ac0 --- /dev/null +++ b/snippets/databases/sql_examples.py @@ -0,0 +1,637 @@ +#!/usr/bin/env python3 +""" +SQL Examples for Relational Databases in Python + +This file demonstrates using SQL with different database engines in Python. +It includes examples for SQLite, PostgreSQL, and MySQL. +""" + +import sqlite3 +import os +from datetime import datetime + +# Try to import optional database libraries +try: + import psycopg2 + POSTGRESQL_AVAILABLE = True +except ImportError: + POSTGRESQL_AVAILABLE = False + +try: + import mysql.connector + MYSQL_AVAILABLE = True +except ImportError: + MYSQL_AVAILABLE = False + +# Try to import dotenv for environment variables +try: + from dotenv import load_dotenv + DOTENV_AVAILABLE = True + # Load environment variables from .env file + load_dotenv() +except ImportError: + DOTENV_AVAILABLE = False + print("python-dotenv is not installed. Install it with: pip install python-dotenv") + print("Continuing with default/example values for database credentials.") + + +# Function to get environment variables with fallback to default values +def get_env(key, default): + """Get environment variable with a default fallback value""" + return os.environ.get(key, default) + + +# ============= SQLite Examples ============= + +def sqlite_basic_example(): + """Basic SQLite database operations""" + print("\n=== SQLite Basic Example ===") + + # Connect to SQLite database (creates file if it doesn't exist) + db_path = get_env("SQLITE_DB_PATH", ":memory:") # Default to in-memory database + conn = sqlite3.connect(db_path) + cursor = conn.cursor() + + # Create a table + cursor.execute(''' + CREATE TABLE IF NOT EXISTS users ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT UNIQUE NOT NULL, + age INTEGER, + created_at TEXT + ) + ''') + + # Insert data + users = [ + ('Alice', 'alice@example.com', 28, datetime.now().isoformat()), + ('Bob', 'bob@example.com', 35, datetime.now().isoformat()), + ('Charlie', 'charlie@example.com', 42, datetime.now().isoformat()), + ] + + cursor.executemany( + 'INSERT INTO users (name, email, age, created_at) VALUES (?, ?, ?, ?)', + users + ) + + # Commit the changes + conn.commit() + + # Query the database + print("All users:") + cursor.execute('SELECT * FROM users') + for row in cursor.fetchall(): + print(row) + + # Filtered query + print("\nUsers older than 30:") + cursor.execute('SELECT name, age FROM users WHERE age > ?', (30,)) + for name, age in cursor.fetchall(): + print(f"{name}: {age} years old") + + # Update data + cursor.execute( + 'UPDATE users SET age = ? WHERE name = ?', + (29, 'Alice') + ) + conn.commit() + + # Delete data + cursor.execute('DELETE FROM users WHERE name = ?', ('Charlie',)) + conn.commit() + + # Check the results + print("\nAfter update and delete:") + cursor.execute('SELECT * FROM users') + for row in cursor.fetchall(): + print(row) + + # Close the connection + conn.close() + + +def sqlite_advanced_example(): + """Advanced SQLite operations including JOINs, transactions, and more""" + print("\n=== SQLite Advanced Example ===") + + # Connect to SQLite database + db_path = get_env("SQLITE_DB_PATH", ":memory:") # Default to in-memory database + conn = sqlite3.connect(db_path) + conn.row_factory = sqlite3.Row # Return rows as dictionary-like objects + cursor = conn.cursor() + + # Create tables for a blog application + cursor.executescript(''' + CREATE TABLE IF NOT EXISTS authors ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + email TEXT UNIQUE NOT NULL + ); + + CREATE TABLE IF NOT EXISTS categories ( + id INTEGER PRIMARY KEY, + name TEXT UNIQUE NOT NULL + ); + + CREATE TABLE IF NOT EXISTS posts ( + id INTEGER PRIMARY KEY, + title TEXT NOT NULL, + content TEXT NOT NULL, + author_id INTEGER NOT NULL, + category_id INTEGER NOT NULL, + published_at TEXT NOT NULL, + FOREIGN KEY (author_id) REFERENCES authors (id), + FOREIGN KEY (category_id) REFERENCES categories (id) + ); + + CREATE TABLE IF NOT EXISTS comments ( + id INTEGER PRIMARY KEY, + post_id INTEGER NOT NULL, + author_name TEXT NOT NULL, + content TEXT NOT NULL, + created_at TEXT NOT NULL, + FOREIGN KEY (post_id) REFERENCES posts (id) + ); + ''') + + # Insert data using a transaction + try: + conn.execute('BEGIN TRANSACTION') + + # Insert authors + cursor.executemany( + 'INSERT INTO authors (name, email) VALUES (?, ?)', + [ + ('John Smith', 'john@example.com'), + ('Jane Doe', 'jane@example.com') + ] + ) + + # Insert categories + cursor.executemany( + 'INSERT INTO categories (name) VALUES (?)', + [('Technology',), ('Travel',), ('Food',)] + ) + + # Insert posts + now = datetime.now().isoformat() + cursor.executemany( + 'INSERT INTO posts (title, content, author_id, category_id, published_at) VALUES (?, ?, ?, ?, ?)', + [ + ('Python Tips', 'Content about Python...', 1, 1, now), + ('Trip to Paris', 'My journey to Paris...', 2, 2, now), + ('Best Pizza Recipes', 'How to make pizza...', 1, 3, now) + ] + ) + + # Insert comments + cursor.executemany( + 'INSERT INTO comments (post_id, author_name, content, created_at) VALUES (?, ?, ?, ?)', + [ + (1, 'Anonymous', 'Great tips!', now), + (1, 'Coder123', 'I learned a lot!', now), + (2, 'Traveler', 'Paris is amazing!', now) + ] + ) + + conn.commit() + print("Transaction committed successfully") + + except Exception as e: + conn.rollback() + print(f"Transaction failed: {e}") + + # Perform a JOIN query to get posts with author and category information + print("\nPosts with author and category:") + query = ''' + SELECT + p.title, + a.name AS author, + c.name AS category, + p.published_at + FROM + posts p + JOIN + authors a ON p.author_id = a.id + JOIN + categories c ON p.category_id = c.id + ORDER BY + p.published_at DESC + ''' + + cursor.execute(query) + for row in cursor: + print(f"'{row['title']}' by {row['author']} in {row['category']} ({row['published_at']})") + + # Count comments per post + print("\nComment count per post:") + query = ''' + SELECT + p.title, + COUNT(c.id) AS comment_count + FROM + posts p + LEFT JOIN + comments c ON p.id = c.post_id + GROUP BY + p.id + ORDER BY + comment_count DESC + ''' + + cursor.execute(query) + for row in cursor: + print(f"'{row['title']}': {row['comment_count']} comments") + + # Aggregate functions + print("\nAuthor statistics:") + query = ''' + SELECT + a.name, + COUNT(p.id) AS post_count, + COUNT(c.id) AS comment_count + FROM + authors a + LEFT JOIN + posts p ON a.id = p.author_id + LEFT JOIN + comments c ON p.id = c.post_id + GROUP BY + a.id + ''' + + cursor.execute(query) + for row in cursor: + print(f"{row['name']}: {row['post_count']} posts, {row['comment_count']} comments") + + # Using subqueries + print("\nPosts with more than 1 comment:") + query = ''' + SELECT + p.title, + (SELECT COUNT(*) FROM comments WHERE post_id = p.id) AS comment_count + FROM + posts p + WHERE + (SELECT COUNT(*) FROM comments WHERE post_id = p.id) > 1 + ''' + + cursor.execute(query) + for row in cursor: + print(f"'{row['title']}': {row['comment_count']} comments") + + # Close the connection + conn.close() + + +# ============= PostgreSQL Examples ============= + +def postgresql_example(): + """PostgreSQL database operations""" + if not POSTGRESQL_AVAILABLE: + print("\n=== PostgreSQL Example ===") + print("psycopg2 module is not installed. Install it with: pip install psycopg2-binary") + return + + # This code won't run unless psycopg2 is installed + print("\n=== PostgreSQL Example ===") + print("To run this example, you need a PostgreSQL server, the psycopg2 module, and proper environment variables.") + print("Normally, this would use credentials from .env. Sample code:") + + # Connection parameters from environment variables + params = { + 'host': get_env('PG_HOST', 'localhost'), + 'database': get_env('PG_DATABASE', 'mydb'), + 'user': get_env('PG_USER', 'postgres'), + 'password': get_env('PG_PASSWORD', 'password') # In real code, no default should be provided + } + + print(f"Would connect to: {params['host']}/{params['database']} as {params['user']}") + print("The actual implementation would execute:") + + """ + # Connect to PostgreSQL server + conn = psycopg2.connect(**params) + cursor = conn.cursor() + + # Create a table with PostgreSQL-specific features + cursor.execute(''' + CREATE TABLE IF NOT EXISTS products ( + id SERIAL PRIMARY KEY, + name VARCHAR(100) NOT NULL, + description TEXT, + price DECIMAL(10,2) NOT NULL, + created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP, + tags TEXT[], + metadata JSONB + ) + ''') + conn.commit() + + # Insert data with PostgreSQL-specific data types + cursor.execute(''' + INSERT INTO products (name, description, price, tags, metadata) + VALUES (%s, %s, %s, %s, %s) + ''', ( + 'Laptop', + 'High-performance laptop', + 999.99, + ['electronics', 'computers'], + {'brand': 'TechBrand', 'warranty': '2 years', 'specs': {'cpu': 'i7', 'ram': '16GB'}} + )) + conn.commit() + + # Query with PostgreSQL-specific features + cursor.execute(''' + SELECT + name, + price, + metadata->>'brand' AS brand, + metadata->'specs'->>'cpu' AS cpu + FROM + products + WHERE + 'electronics' = ANY(tags) + ''') + + for row in cursor.fetchall(): + print(row) + + # Using PostgreSQL-specific functions + cursor.execute(''' + SELECT + name, + price, + extract(year from created_at) AS year, + array_length(tags, 1) AS tag_count + FROM + products + ''') + + for row in cursor.fetchall(): + print(row) + + conn.close() + """ + + +# ============= MySQL Examples ============= + +def mysql_example(): + """MySQL database operations""" + if not MYSQL_AVAILABLE: + print("\n=== MySQL Example ===") + print("mysql-connector-python module is not installed. Install it with: pip install mysql-connector-python") + return + + # This code won't run unless mysql-connector is installed + print("\n=== MySQL Example ===") + print("To run this example, you need a MySQL server, the mysql-connector-python module, and proper environment variables.") + print("Normally, this would use credentials from .env. Sample code:") + + # Connection parameters from environment variables + config = { + 'host': get_env('MYSQL_HOST', 'localhost'), + 'database': get_env('MYSQL_DATABASE', 'mydb'), + 'user': get_env('MYSQL_USER', 'root'), + 'password': get_env('MYSQL_PASSWORD', 'password') # In real code, no default should be provided + } + + print(f"Would connect to: {config['host']}/{config['database']} as {config['user']}") + print("The actual implementation would execute:") + + """ + # Connect to MySQL server + conn = mysql.connector.connect(**config) + cursor = conn.cursor() + + # Create a table with MySQL-specific features + cursor.execute(''' + CREATE TABLE IF NOT EXISTS orders ( + id INT AUTO_INCREMENT PRIMARY KEY, + customer_name VARCHAR(100) NOT NULL, + total DECIMAL(10,2) NOT NULL, + status ENUM('pending', 'shipped', 'delivered') NOT NULL, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + INDEX idx_status (status), + INDEX idx_created_at (created_at) + ) ENGINE=InnoDB + ''') + conn.commit() + + # Insert data + cursor.execute(''' + INSERT INTO orders (customer_name, total, status) + VALUES (%s, %s, %s) + ''', ('John Doe', 123.45, 'pending')) + + last_id = cursor.lastrowid + print(f"Inserted order with ID: {last_id}") + conn.commit() + + # MySQL-specific date functions + cursor.execute(''' + SELECT + id, + customer_name, + total, + status, + DATE_FORMAT(created_at, '%Y-%m-%d %H:%i:%s') AS formatted_date, + DATEDIFF(NOW(), created_at) AS days_since_creation + FROM + orders + WHERE + created_at > DATE_SUB(NOW(), INTERVAL 7 DAY) + ''') + + for row in cursor: + print(row) + + conn.close() + """ + + +# ============= ORM Example with SQLAlchemy ============= + +def sqlalchemy_example(): + """Example of using SQLAlchemy ORM""" + try: + from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, ForeignKey, func + from sqlalchemy.ext.declarative import declarative_base + from sqlalchemy.orm import sessionmaker, relationship + except ImportError: + print("\n=== SQLAlchemy ORM Example ===") + print("SQLAlchemy is not installed. Install it with: pip install sqlalchemy") + return + + print("\n=== SQLAlchemy ORM Example ===") + + # Database URL from environment variables + # Example: postgresql://user:password@localhost/dbname + db_url = get_env('SQLALCHEMY_DATABASE_URL', 'sqlite:///:memory:') + print(f"Using database URL: {db_url}") + + # Create engine and base + engine = create_engine(db_url) + Base = declarative_base() + + # Define models + class Customer(Base): + __tablename__ = 'customers' + + id = Column(Integer, primary_key=True) + name = Column(String(100), nullable=False) + email = Column(String(100), unique=True, nullable=False) + + # Relationship + orders = relationship("Order", back_populates="customer") + + def __repr__(self): + return f"" + + class Product(Base): + __tablename__ = 'products' + + id = Column(Integer, primary_key=True) + name = Column(String(100), nullable=False) + price = Column(Float, nullable=False) + + # Relationship + order_items = relationship("OrderItem", back_populates="product") + + def __repr__(self): + return f"" + + class Order(Base): + __tablename__ = 'orders' + + id = Column(Integer, primary_key=True) + customer_id = Column(Integer, ForeignKey('customers.id'), nullable=False) + created_at = Column(DateTime, default=datetime.now) + + # Relationships + customer = relationship("Customer", back_populates="orders") + items = relationship("OrderItem", back_populates="order") + + def __repr__(self): + return f"" + + class OrderItem(Base): + __tablename__ = 'order_items' + + id = Column(Integer, primary_key=True) + order_id = Column(Integer, ForeignKey('orders.id'), nullable=False) + product_id = Column(Integer, ForeignKey('products.id'), nullable=False) + quantity = Column(Integer, default=1) + + # Relationships + order = relationship("Order", back_populates="items") + product = relationship("Product", back_populates="order_items") + + def __repr__(self): + return f"" + + # Create tables + Base.metadata.create_all(engine) + + # Create session + Session = sessionmaker(bind=engine) + session = Session() + + # Add data + try: + # Add customers + customer1 = Customer(name="Alice Smith", email="alice@example.com") + customer2 = Customer(name="Bob Johnson", email="bob@example.com") + session.add_all([customer1, customer2]) + + # Add products + product1 = Product(name="Laptop", price=999.99) + product2 = Product(name="Smartphone", price=499.99) + product3 = Product(name="Headphones", price=99.99) + session.add_all([product1, product2, product3]) + + # Commit to get IDs + session.commit() + + # Create orders + order1 = Order(customer_id=customer1.id) + session.add(order1) + session.commit() + + # Add items to order + item1 = OrderItem(order_id=order1.id, product_id=product1.id, quantity=1) + item2 = OrderItem(order_id=order1.id, product_id=product3.id, quantity=2) + session.add_all([item1, item2]) + + order2 = Order(customer_id=customer2.id) + session.add(order2) + session.commit() + + item3 = OrderItem(order_id=order2.id, product_id=product2.id, quantity=1) + session.add(item3) + + session.commit() + + print("Data inserted successfully") + + except Exception as e: + session.rollback() + print(f"Error: {e}") + + # Query with ORM + print("\nAll customers:") + customers = session.query(Customer).all() + for customer in customers: + print(customer) + + print("\nAll products:") + products = session.query(Product).all() + for product in products: + print(product) + + print("\nOrders with customer info:") + orders = session.query(Order, Customer.name).join(Customer).all() + for order, customer_name in orders: + print(f"Order {order.id} by {customer_name}") + + print("\nOrder details:") + order_details = session.query( + Order.id.label('order_id'), + Customer.name.label('customer'), + Product.name.label('product'), + OrderItem.quantity, + (Product.price * OrderItem.quantity).label('subtotal') + ).join(Customer).join(OrderItem).join(Product).all() + + for detail in order_details: + print(f"Order #{detail.order_id}: {detail.customer} ordered {detail.quantity}x {detail.product} (${detail.subtotal:.2f})") + + print("\nOrder totals:") + order_totals = session.query( + Order.id, + func.sum(Product.price * OrderItem.quantity).label('total') + ).join(OrderItem).join(Product).group_by(Order.id).all() + + for order_id, total in order_totals: + print(f"Order #{order_id} total: ${total:.2f}") + + # Close session + session.close() + + +if __name__ == "__main__": + # SQLite examples + sqlite_basic_example() + sqlite_advanced_example() + + # PostgreSQL example (requires psycopg2) + postgresql_example() + + # MySQL example (requires mysql-connector-python) + mysql_example() + + # SQLAlchemy ORM example (requires sqlalchemy) + sqlalchemy_example() \ No newline at end of file diff --git a/snippets/design-patterns/factory/FactoryPattern.cpp b/snippets/design-patterns/factory/FactoryPattern.cpp new file mode 100644 index 0000000..3ceb7a8 --- /dev/null +++ b/snippets/design-patterns/factory/FactoryPattern.cpp @@ -0,0 +1,362 @@ +/** + * Factory Pattern Implementation in C++ + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + */ + +#include +#include +#include +#include + +// Abstract Product - Vehicle +class Vehicle { +public: + Vehicle(const std::string& make, const std::string& model, int year) + : make_(make), model_(model), year_(year) {} + + virtual ~Vehicle() = default; + + virtual std::string getInfo() const { + return std::to_string(year_) + " " + make_ + " " + model_; + } + + virtual std::string start() const { + return getInfo() + " is starting..."; + } + + virtual std::string stop() const { + return getInfo() + " is stopping..."; + } + +protected: + std::string make_; + std::string model_; + int year_; +}; + +// Concrete Products +class Car : public Vehicle { +public: + Car(const std::string& make, const std::string& model, int year, int doors = 4) + : Vehicle(make, model, year), doors_(doors) {} + + std::string getInfo() const override { + return Vehicle::getInfo() + " (" + std::to_string(doors_) + "-door car)"; + } + + std::string drive() const { + return getInfo() + " is driving on the road."; + } + +private: + int doors_; +}; + +class Motorcycle : public Vehicle { +public: + Motorcycle(const std::string& make, const std::string& model, int year, int engineSize) + : Vehicle(make, model, year), engineSize_(engineSize) {} + + std::string getInfo() const override { + return Vehicle::getInfo() + " (" + std::to_string(engineSize_) + "cc motorcycle)"; + } + + std::string ride() const { + return getInfo() + " is riding at high speed."; + } + +private: + int engineSize_; +}; + +class Truck : public Vehicle { +public: + Truck(const std::string& make, const std::string& model, int year, double capacity) + : Vehicle(make, model, year), capacity_(capacity) {} + + std::string getInfo() const override { + return Vehicle::getInfo() + " (" + std::to_string(capacity_) + " ton truck)"; + } + + std::string haul() const { + return getInfo() + " is hauling cargo."; + } + +private: + double capacity_; +}; + +// Simple Factory +class VehicleFactory { +public: + enum VehicleType { + CAR, + MOTORCYCLE, + TRUCK + }; + + static std::unique_ptr createVehicle(VehicleType type, + const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) { + switch (type) { + case CAR: + return std::make_unique(make, model, year, + options.size() > 0 ? static_cast(options[0]) : 4); + case MOTORCYCLE: + return std::make_unique(make, model, year, + options.size() > 0 ? static_cast(options[0]) : 250); + case TRUCK: + return std::make_unique(make, model, year, + options.size() > 0 ? options[0] : 5.0); + default: + throw std::invalid_argument("Unknown vehicle type"); + } + } +}; + +// Factory Method Pattern Implementation +class VehicleFactoryMethod { +public: + virtual ~VehicleFactoryMethod() = default; + + virtual std::unique_ptr createVehicle(const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) = 0; + + std::unique_ptr registerVehicle(const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) { + // Common operations for all vehicles + auto vehicle = createVehicle(make, model, year, options); + std::cout << "Registering " << vehicle->getInfo() << std::endl; + std::cout << "Assigning license plate" << std::endl; + return vehicle; + } +}; + +// Concrete Factories +class CarFactory : public VehicleFactoryMethod { +public: + std::unique_ptr createVehicle(const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) override { + return std::make_unique(make, model, year, + options.size() > 0 ? static_cast(options[0]) : 4); + } +}; + +class MotorcycleFactory : public VehicleFactoryMethod { +public: + std::unique_ptr createVehicle(const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) override { + return std::make_unique(make, model, year, + options.size() > 0 ? static_cast(options[0]) : 250); + } +}; + +class TruckFactory : public VehicleFactoryMethod { +public: + std::unique_ptr createVehicle(const std::string& make, + const std::string& model, + int year, + const std::vector& options = {}) override { + return std::make_unique(make, model, year, + options.size() > 0 ? options[0] : 5.0); + } +}; + +// Abstract Factory Pattern Implementation +// Parts interfaces +class Engine { +public: + Engine(const std::string& type, int horsepower) + : type_(type), horsepower_(horsepower) {} + + virtual ~Engine() = default; + + std::string getSpecs() const { + return type_ + " engine with " + std::to_string(horsepower_) + "hp"; + } + +private: + std::string type_; + int horsepower_; +}; + +class Transmission { +public: + Transmission(const std::string& type, int gears) + : type_(type), gears_(gears) {} + + virtual ~Transmission() = default; + + std::string getSpecs() const { + return type_ + " transmission with " + std::to_string(gears_) + " gears"; + } + +private: + std::string type_; + int gears_; +}; + +class Chassis { +public: + Chassis(const std::string& material, double weight) + : material_(material), weight_(weight) {} + + virtual ~Chassis() = default; + + std::string getSpecs() const { + return material_ + " chassis weighing " + std::to_string(weight_) + "kg"; + } + +private: + std::string material_; + double weight_; +}; + +// Abstract Factory +class VehiclePartsFactory { +public: + virtual ~VehiclePartsFactory() = default; + virtual std::unique_ptr createEngine() = 0; + virtual std::unique_ptr createTransmission() = 0; + virtual std::unique_ptr createChassis() = 0; +}; + +// Concrete Abstract Factories +class SportVehiclePartsFactory : public VehiclePartsFactory { +public: + std::unique_ptr createEngine() override { + return std::make_unique("V8", 450); + } + + std::unique_ptr createTransmission() override { + return std::make_unique("Manual", 6); + } + + std::unique_ptr createChassis() override { + return std::make_unique("Carbon Fiber", 120); + } +}; + +class EconomyVehiclePartsFactory : public VehiclePartsFactory { +public: + std::unique_ptr createEngine() override { + return std::make_unique("Inline-4", 180); + } + + std::unique_ptr createTransmission() override { + return std::make_unique("Automatic", 5); + } + + std::unique_ptr createChassis() override { + return std::make_unique("Steel", 300); + } +}; + +class HeavyDutyVehiclePartsFactory : public VehiclePartsFactory { +public: + std::unique_ptr createEngine() override { + return std::make_unique("Diesel V6", 350); + } + + std::unique_ptr createTransmission() override { + return std::make_unique("Manual", 8); + } + + std::unique_ptr createChassis() override { + return std::make_unique("Reinforced Steel", 800); + } +}; + +// Vehicle Assembler - Uses the Abstract Factory +class VehicleAssembler { +public: + VehicleAssembler(std::unique_ptr factory) + : partsFactory_(std::move(factory)) {} + + void assembleVehicle() { + auto engine = partsFactory_->createEngine(); + auto transmission = partsFactory_->createTransmission(); + auto chassis = partsFactory_->createChassis(); + + std::cout << "Assembling vehicle with:" << std::endl; + std::cout << "- " << engine->getSpecs() << std::endl; + std::cout << "- " << transmission->getSpecs() << std::endl; + std::cout << "- " << chassis->getSpecs() << std::endl; + } + +private: + std::unique_ptr partsFactory_; +}; + +// Client code demonstration +void clientCode() { + std::cout << "===== Simple Factory Pattern =====" << std::endl; + + auto car = VehicleFactory::createVehicle(VehicleFactory::CAR, "Toyota", "Camry", 2023, {4}); + auto motorcycle = VehicleFactory::createVehicle(VehicleFactory::MOTORCYCLE, "Honda", "CBR", 2023, {600}); + auto truck = VehicleFactory::createVehicle(VehicleFactory::TRUCK, "Ford", "F-150", 2023, {3.0}); + + std::cout << car->getInfo() << std::endl; + std::cout << static_cast(car.get())->drive() << std::endl; + + std::cout << motorcycle->getInfo() << std::endl; + std::cout << static_cast(motorcycle.get())->ride() << std::endl; + + std::cout << truck->getInfo() << std::endl; + std::cout << static_cast(truck.get())->haul() << std::endl; + + std::cout << "\n===== Factory Method Pattern =====" << std::endl; + + CarFactory carFactory; + MotorcycleFactory motorcycleFactory; + TruckFactory truckFactory; + + auto newCar = carFactory.registerVehicle("BMW", "3 Series", 2023, {2}); + auto newMotorcycle = motorcycleFactory.registerVehicle("Ducati", "Monster", 2023, {821}); + auto newTruck = truckFactory.registerVehicle("Volvo", "VNL", 2023, {20.0}); + + std::cout << static_cast(newCar.get())->drive() << std::endl; + std::cout << static_cast(newMotorcycle.get())->ride() << std::endl; + std::cout << static_cast(newTruck.get())->haul() << std::endl; + + std::cout << "\n===== Abstract Factory Pattern =====" << std::endl; + + std::cout << "Building a sports car:" << std::endl; + VehicleAssembler sportCarAssembler(std::make_unique()); + sportCarAssembler.assembleVehicle(); + + std::cout << "\nBuilding an economy car:" << std::endl; + VehicleAssembler economyCarAssembler(std::make_unique()); + economyCarAssembler.assembleVehicle(); + + std::cout << "\nBuilding a heavy duty truck:" << std::endl; + VehicleAssembler heavyDutyTruckAssembler(std::make_unique()); + heavyDutyTruckAssembler.assembleVehicle(); +} + +// Main function, run the example +int main() { + try { + clientCode(); + } catch (const std::exception& e) { + std::cerr << "Exception: " << e.what() << std::endl; + return 1; + } + return 0; +} + diff --git a/snippets/design-patterns/factory/FactoryPattern.cs b/snippets/design-patterns/factory/FactoryPattern.cs new file mode 100644 index 0000000..fb42d26 --- /dev/null +++ b/snippets/design-patterns/factory/FactoryPattern.cs @@ -0,0 +1,407 @@ +/** + * Factory Pattern Implementation in C# + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + */ + +using System; +using System.Collections.Generic; + +namespace DesignPatterns.Factory +{ + // Abstract Product - Vehicle + public abstract class Vehicle + { + protected string Make { get; } + protected string Model { get; } + protected int Year { get; } + + protected Vehicle(string make, string model, int year) + { + Make = make; + Model = model; + Year = year; + } + + public virtual string GetInfo() + { + return $"{Year} {Make} {Model}"; + } + + public virtual string Start() + { + return $"{GetInfo()} is starting..."; + } + + public virtual string Stop() + { + return $"{GetInfo()} is stopping..."; + } + } + + // Concrete Products + public class Car : Vehicle + { + public int Doors { get; } + + public Car(string make, string model, int year, int doors = 4) + : base(make, model, year) + { + Doors = doors; + } + + public override string GetInfo() + { + return $"{base.GetInfo()} ({Doors}-door car)"; + } + + public string Drive() + { + return $"{GetInfo()} is driving on the road."; + } + } + + public class Motorcycle : Vehicle + { + public int EngineSize { get; } + + public Motorcycle(string make, string model, int year, int engineSize) + : base(make, model, year) + { + EngineSize = engineSize; + } + + public override string GetInfo() + { + return $"{base.GetInfo()} ({EngineSize}cc motorcycle)"; + } + + public string Ride() + { + return $"{GetInfo()} is riding at high speed."; + } + } + + public class Truck : Vehicle + { + public double Capacity { get; } + + public Truck(string make, string model, int year, double capacity) + : base(make, model, year) + { + Capacity = capacity; + } + + public override string GetInfo() + { + return $"{base.GetInfo()} ({Capacity} ton truck)"; + } + + public string Haul() + { + return $"{GetInfo()} is hauling cargo."; + } + } + + // Simple Factory + public class VehicleFactory + { + public enum VehicleType + { + Car, + Motorcycle, + Truck + } + + public static Vehicle CreateVehicle(VehicleType type, string make, string model, int year, object options = null) + { + switch (type) + { + case VehicleType.Car: + int doors = 4; + if (options is int doorsOption) + { + doors = doorsOption; + } + return new Car(make, model, year, doors); + + case VehicleType.Motorcycle: + int engineSize = 250; + if (options is int engineSizeOption) + { + engineSize = engineSizeOption; + } + return new Motorcycle(make, model, year, engineSize); + + case VehicleType.Truck: + double capacity = 5.0; + if (options is double capacityOption) + { + capacity = capacityOption; + } + return new Truck(make, model, year, capacity); + + default: + throw new ArgumentException($"Vehicle type {type} is not supported."); + } + } + } + + // Factory Method Pattern Implementation + public abstract class VehicleFactoryMethod + { + public abstract Vehicle CreateVehicle(string make, string model, int year, object options = null); + + public Vehicle RegisterVehicle(string make, string model, int year, object options = null) + { + // Common operations for all vehicles + Vehicle vehicle = CreateVehicle(make, model, year, options); + Console.WriteLine($"Registering {vehicle.GetInfo()}"); + Console.WriteLine("Assigning license plate"); + return vehicle; + } + } + + // Concrete Factories + public class CarFactory : VehicleFactoryMethod + { + public override Vehicle CreateVehicle(string make, string model, int year, object options = null) + { + int doors = 4; + if (options is int doorsOption) + { + doors = doorsOption; + } + return new Car(make, model, year, doors); + } + } + + public class MotorcycleFactory : VehicleFactoryMethod + { + public override Vehicle CreateVehicle(string make, string model, int year, object options = null) + { + int engineSize = 250; + if (options is int engineSizeOption) + { + engineSize = engineSizeOption; + } + return new Motorcycle(make, model, year, engineSize); + } + } + + public class TruckFactory : VehicleFactoryMethod + { + public override Vehicle CreateVehicle(string make, string model, int year, object options = null) + { + double capacity = 5.0; + if (options is double capacityOption) + { + capacity = capacityOption; + } + return new Truck(make, model, year, capacity); + } + } + + // Abstract Factory Pattern Implementation + // Parts + public class Engine + { + public string Type { get; } + public int Horsepower { get; } + + public Engine(string type, int horsepower) + { + Type = type; + Horsepower = horsepower; + } + + public string GetSpecs() + { + return $"{Type} engine with {Horsepower}hp"; + } + } + + public class Transmission + { + public string Type { get; } + public int Gears { get; } + + public Transmission(string type, int gears) + { + Type = type; + Gears = gears; + } + + public string GetSpecs() + { + return $"{Type} transmission with {Gears} gears"; + } + } + + public class Chassis + { + public string Material { get; } + public double Weight { get; } + + public Chassis(string material, double weight) + { + Material = material; + Weight = weight; + } + + public string GetSpecs() + { + return $"{Material} chassis weighing {Weight}kg"; + } + } + + // Abstract Factory + public interface IVehiclePartsFactory + { + Engine CreateEngine(); + Transmission CreateTransmission(); + Chassis CreateChassis(); + } + + // Concrete Abstract Factories + public class SportVehiclePartsFactory : IVehiclePartsFactory + { + public Engine CreateEngine() + { + return new Engine("V8", 450); + } + + public Transmission CreateTransmission() + { + return new Transmission("Manual", 6); + } + + public Chassis CreateChassis() + { + return new Chassis("Carbon Fiber", 120); + } + } + + public class EconomyVehiclePartsFactory : IVehiclePartsFactory + { + public Engine CreateEngine() + { + return new Engine("Inline-4", 180); + } + + public Transmission CreateTransmission() + { + return new Transmission("Automatic", 5); + } + + public Chassis CreateChassis() + { + return new Chassis("Steel", 300); + } + } + + public class HeavyDutyVehiclePartsFactory : IVehiclePartsFactory + { + public Engine CreateEngine() + { + return new Engine("Diesel V6", 350); + } + + public Transmission CreateTransmission() + { + return new Transmission("Manual", 8); + } + + public Chassis CreateChassis() + { + return new Chassis("Reinforced Steel", 800); + } + } + + // Vehicle Assembler - Uses the Abstract Factory + public class VehicleAssembler + { + private readonly IVehiclePartsFactory _partsFactory; + + public VehicleAssembler(IVehiclePartsFactory partsFactory) + { + _partsFactory = partsFactory; + } + + public void AssembleVehicle() + { + Engine engine = _partsFactory.CreateEngine(); + Transmission transmission = _partsFactory.CreateTransmission(); + Chassis chassis = _partsFactory.CreateChassis(); + + Console.WriteLine("Assembling vehicle with:"); + Console.WriteLine($"- {engine.GetSpecs()}"); + Console.WriteLine($"- {transmission.GetSpecs()}"); + Console.WriteLine($"- {chassis.GetSpecs()}"); + } + } + + // Client code demonstration + public class Client + { + public static void DemonstrateFactoryPattern() + { + Console.WriteLine("===== Simple Factory Pattern ====="); + + Vehicle car = VehicleFactory.CreateVehicle(VehicleFactory.VehicleType.Car, "Toyota", "Camry", 2023, 4); + Vehicle motorcycle = VehicleFactory.CreateVehicle(VehicleFactory.VehicleType.Motorcycle, "Honda", "CBR", 2023, 600); + Vehicle truck = VehicleFactory.CreateVehicle(VehicleFactory.VehicleType.Truck, "Ford", "F-150", 2023, 3.0); + + Console.WriteLine(car.GetInfo()); + Console.WriteLine(((Car)car).Drive()); + + Console.WriteLine(motorcycle.GetInfo()); + Console.WriteLine(((Motorcycle)motorcycle).Ride()); + + Console.WriteLine(truck.GetInfo()); + Console.WriteLine(((Truck)truck).Haul()); + + Console.WriteLine("\n===== Factory Method Pattern ====="); + + CarFactory carFactory = new CarFactory(); + MotorcycleFactory motorcycleFactory = new MotorcycleFactory(); + TruckFactory truckFactory = new TruckFactory(); + + Vehicle newCar = carFactory.RegisterVehicle("BMW", "3 Series", 2023, 2); + Vehicle newMotorcycle = motorcycleFactory.RegisterVehicle("Ducati", "Monster", 2023, 821); + Vehicle newTruck = truckFactory.RegisterVehicle("Volvo", "VNL", 2023, 20.0); + + Console.WriteLine(((Car)newCar).Drive()); + Console.WriteLine(((Motorcycle)newMotorcycle).Ride()); + Console.WriteLine(((Truck)newTruck).Haul()); + + Console.WriteLine("\n===== Abstract Factory Pattern ====="); + + Console.WriteLine("Building a sports car:"); + VehicleAssembler sportCarAssembler = new VehicleAssembler(new SportVehiclePartsFactory()); + sportCarAssembler.AssembleVehicle(); + + Console.WriteLine("\nBuilding an economy car:"); + VehicleAssembler economyCarAssembler = new VehicleAssembler(new EconomyVehiclePartsFactory()); + economyCarAssembler.AssembleVehicle(); + + Console.WriteLine("\nBuilding a heavy duty truck:"); + VehicleAssembler heavyDutyTruckAssembler = new VehicleAssembler(new HeavyDutyVehiclePartsFactory()); + heavyDutyTruckAssembler.AssembleVehicle(); + } + } + + // Main program, run the example + class Program + { + static void Main(string[] args) + { + Client.DemonstrateFactoryPattern(); + Console.ReadLine(); + } + } +} diff --git a/snippets/design-patterns/factory/FactoryPattern.java b/snippets/design-patterns/factory/FactoryPattern.java new file mode 100644 index 0000000..ce77cfa --- /dev/null +++ b/snippets/design-patterns/factory/FactoryPattern.java @@ -0,0 +1,288 @@ +/** + * Factory Pattern Implementation in Java + * + * This demonstrates three variations of the Factory Pattern: + * 1. Simple Factory + * 2. Factory Method + * 3. Abstract Factory + */ + +// ============= SIMPLE FACTORY EXAMPLE ============= + +// Product interface +interface Product { + void operation(); +} + +// Concrete products +class ConcreteProductA implements Product { + @Override + public void operation() { + System.out.println("Operation of ConcreteProductA"); + } +} + +class ConcreteProductB implements Product { + @Override + public void operation() { + System.out.println("Operation of ConcreteProductB"); + } +} + +// Simple factory +class SimpleFactory { + public Product createProduct(String type) { + if (type.equals("A")) { + return new ConcreteProductA(); + } else if (type.equals("B")) { + return new ConcreteProductB(); + } + throw new IllegalArgumentException("Invalid product type: " + type); + } +} + +// Client for Simple Factory +class SimpleFactoryClient { + public void run() { + System.out.println("\n=== Simple Factory Example ==="); + SimpleFactory factory = new SimpleFactory(); + + Product productA = factory.createProduct("A"); + productA.operation(); + + Product productB = factory.createProduct("B"); + productB.operation(); + } +} + +// ============= FACTORY METHOD EXAMPLE ============= + +// Product interface for Factory Method +interface Transport { + void deliver(); +} + +// Concrete products +class Truck implements Transport { + @Override + public void deliver() { + System.out.println("Delivering by land in a truck"); + } +} + +class Ship implements Transport { + @Override + public void deliver() { + System.out.println("Delivering by sea in a ship"); + } +} + +// Creator abstract class with factory method +abstract class Logistics { + // Factory method + public abstract Transport createTransport(); + + // Business logic that uses the factory method + public void planDelivery() { + System.out.println("Preparing for delivery..."); + Transport transport = createTransport(); + System.out.println("Planning route..."); + transport.deliver(); + System.out.println("Delivery complete!"); + } +} + +// Concrete creators override factory method +class RoadLogistics extends Logistics { + @Override + public Transport createTransport() { + return new Truck(); + } +} + +class SeaLogistics extends Logistics { + @Override + public Transport createTransport() { + return new Ship(); + } +} + +// Client for Factory Method +class FactoryMethodClient { + public void run() { + System.out.println("\n=== Factory Method Example ==="); + + System.out.println("\nRoad delivery:"); + Logistics roadLogistics = new RoadLogistics(); + roadLogistics.planDelivery(); + + System.out.println("\nSea delivery:"); + Logistics seaLogistics = new SeaLogistics(); + seaLogistics.planDelivery(); + } +} + +// ============= ABSTRACT FACTORY EXAMPLE ============= + +// Abstract products +interface Button { + void render(); + void click(); +} + +interface Checkbox { + void render(); + void toggle(); +} + +// Concrete products for Windows +class WindowsButton implements Button { + @Override + public void render() { + System.out.println("Rendering a Windows button"); + } + + @Override + public void click() { + System.out.println("Windows button clicked"); + } +} + +class WindowsCheckbox implements Checkbox { + @Override + public void render() { + System.out.println("Rendering a Windows checkbox"); + } + + @Override + public void toggle() { + System.out.println("Windows checkbox toggled"); + } +} + +// Concrete products for macOS +class MacOSButton implements Button { + @Override + public void render() { + System.out.println("Rendering a macOS button"); + } + + @Override + public void click() { + System.out.println("macOS button clicked"); + } +} + +class MacOSCheckbox implements Checkbox { + @Override + public void render() { + System.out.println("Rendering a macOS checkbox"); + } + + @Override + public void toggle() { + System.out.println("macOS checkbox toggled"); + } +} + +// Abstract factory interface +interface GUIFactory { + Button createButton(); + Checkbox createCheckbox(); +} + +// Concrete factories +class WindowsFactory implements GUIFactory { + @Override + public Button createButton() { + return new WindowsButton(); + } + + @Override + public Checkbox createCheckbox() { + return new WindowsCheckbox(); + } +} + +class MacOSFactory implements GUIFactory { + @Override + public Button createButton() { + return new MacOSButton(); + } + + @Override + public Checkbox createCheckbox() { + return new MacOSCheckbox(); + } +} + +// Client code that works with factories and products +class Application { + private Button button; + private Checkbox checkbox; + + public Application(GUIFactory factory) { + button = factory.createButton(); + checkbox = factory.createCheckbox(); + } + + public void createUI() { + System.out.println("Creating UI components..."); + button.render(); + checkbox.render(); + } + + public void clickButton() { + button.click(); + } + + public void toggleCheckbox() { + checkbox.toggle(); + } +} + +// Client for Abstract Factory +class AbstractFactoryClient { + public void run() { + System.out.println("\n=== Abstract Factory Example ==="); + + // Simulate different OS environments + createApplicationFor("Windows"); + createApplicationFor("macOS"); + } + + private void createApplicationFor(String os) { + System.out.println("\nCreating app for " + os); + + GUIFactory factory; + if (os.equals("Windows")) { + factory = new WindowsFactory(); + } else if (os.equals("macOS")) { + factory = new MacOSFactory(); + } else { + throw new IllegalArgumentException("Unknown OS: " + os); + } + + Application app = new Application(factory); + app.createUI(); + app.clickButton(); + app.toggleCheckbox(); + } +} + +// Main class to run all examples +public class FactoryPattern { + public static void main(String[] args) { + System.out.println("Factory Pattern Demonstrations"); + System.out.println("=============================="); + + // Run Simple Factory example + new SimpleFactoryClient().run(); + + // Run Factory Method example + new FactoryMethodClient().run(); + + // Run Abstract Factory example + new AbstractFactoryClient().run(); + } +} \ No newline at end of file diff --git a/snippets/design-patterns/factory/factory_pattern.c b/snippets/design-patterns/factory/factory_pattern.c new file mode 100644 index 0000000..9024782 --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.c @@ -0,0 +1,547 @@ +/** + * Factory Pattern Implementation in C + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + * + * Note: Since C is not an object-oriented language, we use structs with function pointers + * to simulate classes and polymorphism. + */ + +#include +#include +#include +#include + +// Define vehicle types +typedef enum { + VEHICLE_TYPE_CAR, + VEHICLE_TYPE_MOTORCYCLE, + VEHICLE_TYPE_TRUCK +} VehicleType; + +// Forward declarations +typedef struct Vehicle Vehicle; +typedef struct Car Car; +typedef struct Motorcycle Motorcycle; +typedef struct Truck Truck; + +// Function pointer types for common vehicle methods +typedef char* (*GetInfoFunc)(const void*); +typedef char* (*StartFunc)(const void*); +typedef char* (*StopFunc)(const void*); + +// Base "class" for vehicles +struct Vehicle { + char make[50]; + char model[50]; + int year; + + // Virtual functions (function pointers) + GetInfoFunc getInfo; + StartFunc start; + StopFunc stop; +}; + +// Car "class" +struct Car { + Vehicle base; // "Inherit" from Vehicle + int doors; + + // Car-specific method + char* (*drive)(const Car*); +}; + +// Motorcycle "class" +struct Motorcycle { + Vehicle base; // "Inherit" from Vehicle + int engineSize; + + // Motorcycle-specific method + char* (*ride)(const Motorcycle*); +}; + +// Truck "class" +struct Truck { + Vehicle base; // "Inherit" from Vehicle + double capacity; + + // Truck-specific method + char* (*haul)(const Truck*); +}; + +// Helper function to create a string (caller must free) +char* createString(const char* format, ...) { + char* buffer = NULL; + va_list args; + int length; + + va_start(args, format); + length = vsnprintf(NULL, 0, format, args); + va_end(args); + + buffer = (char*)malloc(length + 1); + if (buffer == NULL) { + return NULL; + } + + va_start(args, format); + vsnprintf(buffer, length + 1, format, args); + va_end(args); + + return buffer; +} + +// Vehicle method implementations +char* vehicle_getInfo(const Vehicle* vehicle) { + return createString("%d %s %s", vehicle->year, vehicle->make, vehicle->model); +} + +char* vehicle_start(const Vehicle* vehicle) { + char* info = vehicle->getInfo(vehicle); + char* result = createString("%s is starting...", info); + free(info); + return result; +} + +char* vehicle_stop(const Vehicle* vehicle) { + char* info = vehicle->getInfo(vehicle); + char* result = createString("%s is stopping...", info); + free(info); + return result; +} + +// Car method implementations +char* car_getInfo(const Car* car) { + char* baseInfo = vehicle_getInfo((Vehicle*)car); + char* result = createString("%s (%d-door car)", baseInfo, car->doors); + free(baseInfo); + return result; +} + +char* car_drive(const Car* car) { + char* info = car_getInfo(car); + char* result = createString("%s is driving on the road.", info); + free(info); + return result; +} + +// Motorcycle method implementations +char* motorcycle_getInfo(const Motorcycle* motorcycle) { + char* baseInfo = vehicle_getInfo((Vehicle*)motorcycle); + char* result = createString("%s (%dcc motorcycle)", baseInfo, motorcycle->engineSize); + free(baseInfo); + return result; +} + +char* motorcycle_ride(const Motorcycle* motorcycle) { + char* info = motorcycle_getInfo(motorcycle); + char* result = createString("%s is riding at high speed.", info); + free(info); + return result; +} + +// Truck method implementations +char* truck_getInfo(const Truck* truck) { + char* baseInfo = vehicle_getInfo((Vehicle*)truck); + char* result = createString("%s (%.1f ton truck)", baseInfo, truck->capacity); + free(baseInfo); + return result; +} + +char* truck_haul(const Truck* truck) { + char* info = truck_getInfo(truck); + char* result = createString("%s is hauling cargo.", info); + free(info); + return result; +} + +// Factory functions to create vehicles +Car* createCar(const char* make, const char* model, int year, int doors) { + Car* car = (Car*)malloc(sizeof(Car)); + if (car == NULL) { + return NULL; + } + + // Initialize base vehicle + strncpy(car->base.make, make, sizeof(car->base.make) - 1); + strncpy(car->base.model, model, sizeof(car->base.model) - 1); + car->base.year = year; + + // Set function pointers for virtual methods + car->base.getInfo = (GetInfoFunc)car_getInfo; + car->base.start = (StartFunc)vehicle_start; + car->base.stop = (StopFunc)vehicle_stop; + + // Set car-specific properties and methods + car->doors = doors; + car->drive = car_drive; + + return car; +} + +Motorcycle* createMotorcycle(const char* make, const char* model, int year, int engineSize) { + Motorcycle* motorcycle = (Motorcycle*)malloc(sizeof(Motorcycle)); + if (motorcycle == NULL) { + return NULL; + } + + // Initialize base vehicle + strncpy(motorcycle->base.make, make, sizeof(motorcycle->base.make) - 1); + strncpy(motorcycle->base.model, model, sizeof(motorcycle->base.model) - 1); + motorcycle->base.year = year; + + // Set function pointers for virtual methods + motorcycle->base.getInfo = (GetInfoFunc)motorcycle_getInfo; + motorcycle->base.start = (StartFunc)vehicle_start; + motorcycle->base.stop = (StopFunc)vehicle_stop; + + // Set motorcycle-specific properties and methods + motorcycle->engineSize = engineSize; + motorcycle->ride = motorcycle_ride; + + return motorcycle; +} + +Truck* createTruck(const char* make, const char* model, int year, double capacity) { + Truck* truck = (Truck*)malloc(sizeof(Truck)); + if (truck == NULL) { + return NULL; + } + + // Initialize base vehicle + strncpy(truck->base.make, make, sizeof(truck->base.make) - 1); + strncpy(truck->base.model, model, sizeof(truck->base.model) - 1); + truck->base.year = year; + + // Set function pointers for virtual methods + truck->base.getInfo = (GetInfoFunc)truck_getInfo; + truck->base.start = (StartFunc)vehicle_start; + truck->base.stop = (StopFunc)vehicle_stop; + + // Set truck-specific properties and methods + truck->capacity = capacity; + truck->haul = truck_haul; + + return truck; +} + +// Simple Factory +void* vehicleFactory_createVehicle(VehicleType type, const char* make, const char* model, int year, void* options) { + switch (type) { + case VEHICLE_TYPE_CAR: { + int doors = options ? *(int*)options : 4; + return createCar(make, model, year, doors); + } + case VEHICLE_TYPE_MOTORCYCLE: { + int engineSize = options ? *(int*)options : 250; + return createMotorcycle(make, model, year, engineSize); + } + case VEHICLE_TYPE_TRUCK: { + double capacity = options ? *(double*)options : 5.0; + return createTruck(make, model, year, capacity); + } + default: + return NULL; + } +} + +// Factory Method Pattern Implementation +// In C, we would typically use function pointers to implement this pattern +typedef void* (*CreateVehicleFunc)(const char* make, const char* model, int year, void* options); +typedef void* (*RegisterVehicleFunc)(CreateVehicleFunc createFunc, const char* make, const char* model, int year, void* options); + +// Common register vehicle implementation +void* registerVehicle(CreateVehicleFunc createFunc, const char* make, const char* model, int year, void* options) { + void* vehicle = createFunc(make, model, year, options); + + // Common operations for all vehicles + Vehicle* baseVehicle = (Vehicle*)vehicle; + char* info = baseVehicle->getInfo(baseVehicle); + printf("Registering %s\n", info); + printf("Assigning license plate\n"); + free(info); + + return vehicle; +} + +// Concrete factory functions +void* createCarFactory(const char* make, const char* model, int year, void* options) { + int doors = options ? *(int*)options : 4; + return createCar(make, model, year, doors); +} + +void* createMotorcycleFactory(const char* make, const char* model, int year, void* options) { + int engineSize = options ? *(int*)options : 250; + return createMotorcycle(make, model, year, engineSize); +} + +void* createTruckFactory(const char* make, const char* model, int year, void* options) { + double capacity = options ? *(double*)options : 5.0; + return createTruck(make, model, year, capacity); +} + +// Abstract Factory Pattern Implementation +// Parts +typedef struct { + char type[50]; + int horsepower; +} Engine; + +typedef struct { + char type[50]; + int gears; +} Transmission; + +typedef struct { + char material[50]; + double weight; +} Chassis; + +// Function to get engine specs +char* engine_getSpecs(const Engine* engine) { + return createString("%s engine with %dhp", engine->type, engine->horsepower); +} + +// Function to get transmission specs +char* transmission_getSpecs(const Transmission* transmission) { + return createString("%s transmission with %d gears", transmission->type, transmission->gears); +} + +// Function to get chassis specs +char* chassis_getSpecs(const Chassis* chassis) { + return createString("%s chassis weighing %.1fkg", chassis->material, chassis->weight); +} + +// Abstract Factory interface +typedef struct { + Engine* (*createEngine)(); + Transmission* (*createTransmission)(); + Chassis* (*createChassis)(); +} VehiclePartsFactory; + +// Concrete Abstract Factories +Engine* sportVehiclePartsFactory_createEngine() { + Engine* engine = (Engine*)malloc(sizeof(Engine)); + strncpy(engine->type, "V8", sizeof(engine->type) - 1); + engine->horsepower = 450; + return engine; +} + +Transmission* sportVehiclePartsFactory_createTransmission() { + Transmission* transmission = (Transmission*)malloc(sizeof(Transmission)); + strncpy(transmission->type, "Manual", sizeof(transmission->type) - 1); + transmission->gears = 6; + return transmission; +} + +Chassis* sportVehiclePartsFactory_createChassis() { + Chassis* chassis = (Chassis*)malloc(sizeof(Chassis)); + strncpy(chassis->material, "Carbon Fiber", sizeof(chassis->material) - 1); + chassis->weight = 120.0; + return chassis; +} + +Engine* economyVehiclePartsFactory_createEngine() { + Engine* engine = (Engine*)malloc(sizeof(Engine)); + strncpy(engine->type, "Inline-4", sizeof(engine->type) - 1); + engine->horsepower = 180; + return engine; +} + +Transmission* economyVehiclePartsFactory_createTransmission() { + Transmission* transmission = (Transmission*)malloc(sizeof(Transmission)); + strncpy(transmission->type, "Automatic", sizeof(transmission->type) - 1); + transmission->gears = 5; + return transmission; +} + +Chassis* economyVehiclePartsFactory_createChassis() { + Chassis* chassis = (Chassis*)malloc(sizeof(Chassis)); + strncpy(chassis->material, "Steel", sizeof(chassis->material) - 1); + chassis->weight = 300.0; + return chassis; +} + +Engine* heavyDutyVehiclePartsFactory_createEngine() { + Engine* engine = (Engine*)malloc(sizeof(Engine)); + strncpy(engine->type, "Diesel V6", sizeof(engine->type) - 1); + engine->horsepower = 350; + return engine; +} + +Transmission* heavyDutyVehiclePartsFactory_createTransmission() { + Transmission* transmission = (Transmission*)malloc(sizeof(Transmission)); + strncpy(transmission->type, "Manual", sizeof(transmission->type) - 1); + transmission->gears = 8; + return transmission; +} + +Chassis* heavyDutyVehiclePartsFactory_createChassis() { + Chassis* chassis = (Chassis*)malloc(sizeof(Chassis)); + strncpy(chassis->material, "Reinforced Steel", sizeof(chassis->material) - 1); + chassis->weight = 800.0; + return chassis; +} + +// Create concrete factories +VehiclePartsFactory createSportVehiclePartsFactory() { + VehiclePartsFactory factory = { + .createEngine = sportVehiclePartsFactory_createEngine, + .createTransmission = sportVehiclePartsFactory_createTransmission, + .createChassis = sportVehiclePartsFactory_createChassis + }; + return factory; +} + +VehiclePartsFactory createEconomyVehiclePartsFactory() { + VehiclePartsFactory factory = { + .createEngine = economyVehiclePartsFactory_createEngine, + .createTransmission = economyVehiclePartsFactory_createTransmission, + .createChassis = economyVehiclePartsFactory_createChassis + }; + return factory; +} + +VehiclePartsFactory createHeavyDutyVehiclePartsFactory() { + VehiclePartsFactory factory = { + .createEngine = heavyDutyVehiclePartsFactory_createEngine, + .createTransmission = heavyDutyVehiclePartsFactory_createTransmission, + .createChassis = heavyDutyVehiclePartsFactory_createChassis + }; + return factory; +} + +// Vehicle Assembler - Uses the Abstract Factory +void assembleVehicle(const VehiclePartsFactory* factory) { + Engine* engine = factory->createEngine(); + Transmission* transmission = factory->createTransmission(); + Chassis* chassis = factory->createChassis(); + + char* engineSpecs = engine_getSpecs(engine); + char* transmissionSpecs = transmission_getSpecs(transmission); + char* chassisSpecs = chassis_getSpecs(chassis); + + printf("Assembling vehicle with:\n"); + printf("- %s\n", engineSpecs); + printf("- %s\n", transmissionSpecs); + printf("- %s\n", chassisSpecs); + + free(engineSpecs); + free(transmissionSpecs); + free(chassisSpecs); + free(engine); + free(transmission); + free(chassis); +} + +// Free memory functions +void freeCar(Car* car) { + if (car) { + free(car); + } +} + +void freeMotorcycle(Motorcycle* motorcycle) { + if (motorcycle) { + free(motorcycle); + } +} + +void freeTruck(Truck* truck) { + if (truck) { + free(truck); + } +} + +// Client code demonstration +void clientCode() { + printf("===== Simple Factory Pattern =====\n"); + + int carDoors = 4; + int motorcycleEngineSize = 600; + double truckCapacity = 3.0; + + Car* car = vehicleFactory_createVehicle(VEHICLE_TYPE_CAR, "Toyota", "Camry", 2023, &carDoors); + Motorcycle* motorcycle = vehicleFactory_createVehicle(VEHICLE_TYPE_MOTORCYCLE, "Honda", "CBR", 2023, &motorcycleEngineSize); + Truck* truck = vehicleFactory_createVehicle(VEHICLE_TYPE_TRUCK, "Ford", "F-150", 2023, &truckCapacity); + + char* carInfo = car->base.getInfo(car); + char* carDriveResult = car->drive(car); + + char* motorcycleInfo = motorcycle->base.getInfo(motorcycle); + char* motorcycleRideResult = motorcycle->ride(motorcycle); + + char* truckInfo = truck->base.getInfo(truck); + char* truckHaulResult = truck->haul(truck); + + printf("%s\n", carInfo); + printf("%s\n", carDriveResult); + + printf("%s\n", motorcycleInfo); + printf("%s\n", motorcycleRideResult); + + printf("%s\n", truckInfo); + printf("%s\n", truckHaulResult); + + free(carInfo); + free(carDriveResult); + free(motorcycleInfo); + free(motorcycleRideResult); + free(truckInfo); + free(truckHaulResult); + + printf("\n===== Factory Method Pattern =====\n"); + + int bmwDoors = 2; + int ducatiEngineSize = 821; + double volvoCapacity = 20.0; + + Car* newCar = registerVehicle(createCarFactory, "BMW", "3 Series", 2023, &bmwDoors); + Motorcycle* newMotorcycle = registerVehicle(createMotorcycleFactory, "Ducati", "Monster", 2023, &ducatiEngineSize); + Truck* newTruck = registerVehicle(createTruckFactory, "Volvo", "VNL", 2023, &volvoCapacity); + + char* newCarDriveResult = newCar->drive(newCar); + char* newMotorcycleRideResult = newMotorcycle->ride(newMotorcycle); + char* newTruckHaulResult = newTruck->haul(newTruck); + + printf("%s\n", newCarDriveResult); + printf("%s\n", newMotorcycleRideResult); + printf("%s\n", newTruckHaulResult); + + free(newCarDriveResult); + free(newMotorcycleRideResult); + free(newTruckHaulResult); + + printf("\n===== Abstract Factory Pattern =====\n"); + + VehiclePartsFactory sportFactory = createSportVehiclePartsFactory(); + VehiclePartsFactory economyFactory = createEconomyVehiclePartsFactory(); + VehiclePartsFactory heavyDutyFactory = createHeavyDutyVehiclePartsFactory(); + + printf("Building a sports car:\n"); + assembleVehicle(&sportFactory); + + printf("\nBuilding an economy car:\n"); + assembleVehicle(&economyFactory); + + printf("\nBuilding a heavy duty truck:\n"); + assembleVehicle(&heavyDutyFactory); + + // Free memory + freeCar(car); + freeMotorcycle(motorcycle); + freeTruck(truck); + freeCar(newCar); + freeMotorcycle(newMotorcycle); + freeTruck(newTruck); +} + +int main() { + // Run the example + clientCode(); + return 0; +} diff --git a/snippets/design-patterns/factory/factory_pattern.go b/snippets/design-patterns/factory/factory_pattern.go new file mode 100644 index 0000000..26ec4f5 --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.go @@ -0,0 +1,396 @@ +/** + * Factory Pattern Implementation in Go + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + */ + +package main + +import ( + "fmt" + "strconv" +) + +// Vehicle is the abstract product interface +type Vehicle interface { + GetInfo() string + Start() string + Stop() string +} + +// Car is a concrete product +type Car struct { + Make string + Model string + Year int + Doors int +} + +func NewCar(make, model string, year, doors int) *Car { + return &Car{ + Make: make, + Model: model, + Year: year, + Doors: doors, + } +} + +func (c *Car) GetInfo() string { + return strconv.Itoa(c.Year) + " " + c.Make + " " + c.Model + " (" + strconv.Itoa(c.Doors) + "-door car)" +} + +func (c *Car) Start() string { + return c.GetInfo() + " is starting..." +} + +func (c *Car) Stop() string { + return c.GetInfo() + " is stopping..." +} + +func (c *Car) Drive() string { + return c.GetInfo() + " is driving on the road." +} + +// Motorcycle is a concrete product +type Motorcycle struct { + Make string + Model string + Year int + EngineSize int +} + +func NewMotorcycle(make, model string, year, engineSize int) *Motorcycle { + return &Motorcycle{ + Make: make, + Model: model, + Year: year, + EngineSize: engineSize, + } +} + +func (m *Motorcycle) GetInfo() string { + return strconv.Itoa(m.Year) + " " + m.Make + " " + m.Model + " (" + strconv.Itoa(m.EngineSize) + "cc motorcycle)" +} + +func (m *Motorcycle) Start() string { + return m.GetInfo() + " is starting..." +} + +func (m *Motorcycle) Stop() string { + return m.GetInfo() + " is stopping..." +} + +func (m *Motorcycle) Ride() string { + return m.GetInfo() + " is riding at high speed." +} + +// Truck is a concrete product +type Truck struct { + Make string + Model string + Year int + Capacity float64 +} + +func NewTruck(make, model string, year int, capacity float64) *Truck { + return &Truck{ + Make: make, + Model: model, + Year: year, + Capacity: capacity, + } +} + +func (t *Truck) GetInfo() string { + return strconv.Itoa(t.Year) + " " + t.Make + " " + t.Model + " (" + fmt.Sprintf("%.1f", t.Capacity) + " ton truck)" +} + +func (t *Truck) Start() string { + return t.GetInfo() + " is starting..." +} + +func (t *Truck) Stop() string { + return t.GetInfo() + " is stopping..." +} + +func (t *Truck) Haul() string { + return t.GetInfo() + " is hauling cargo." +} + +// VehicleType defines the type of vehicle to create +type VehicleType string + +const ( + CarType VehicleType = "car" + MotorcycleType VehicleType = "motorcycle" + TruckType VehicleType = "truck" +) + +// SimpleVehicleFactory is a simple factory implementation +type SimpleVehicleFactory struct{} + +// CreateVehicle creates a vehicle based on the given type +func (f *SimpleVehicleFactory) CreateVehicle(vehicleType VehicleType, make, model string, year int, options map[string]interface{}) (Vehicle, error) { + switch vehicleType { + case CarType: + doors := 4 // default value + if val, ok := options["doors"]; ok { + if doorsVal, ok := val.(int); ok { + doors = doorsVal + } + } + return NewCar(make, model, year, doors), nil + + case MotorcycleType: + engineSize := 250 // default value + if val, ok := options["engineSize"]; ok { + if engineSizeVal, ok := val.(int); ok { + engineSize = engineSizeVal + } + } + return NewMotorcycle(make, model, year, engineSize), nil + + case TruckType: + capacity := 5.0 // default value + if val, ok := options["capacity"]; ok { + if capacityVal, ok := val.(float64); ok { + capacity = capacityVal + } + } + return NewTruck(make, model, year, capacity), nil + + default: + return nil, fmt.Errorf("unknown vehicle type: %s", vehicleType) + } +} + +// VehicleFactoryMethod is the factory method interface +type VehicleFactoryMethod interface { + CreateVehicle(make, model string, year int, options map[string]interface{}) Vehicle + RegisterVehicle(make, model string, year int, options map[string]interface{}) Vehicle +} + +// CarFactory is a concrete factory implementation +type CarFactory struct{} + +func (f *CarFactory) CreateVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + doors := 4 // default value + if val, ok := options["doors"]; ok { + if doorsVal, ok := val.(int); ok { + doors = doorsVal + } + } + return NewCar(make, model, year, doors) +} + +func (f *CarFactory) RegisterVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + vehicle := f.CreateVehicle(make, model, year, options) + fmt.Printf("Registering %s\n", vehicle.GetInfo()) + fmt.Println("Assigning license plate to car") + return vehicle +} + +// MotorcycleFactory is a concrete factory implementation +type MotorcycleFactory struct{} + +func (f *MotorcycleFactory) CreateVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + engineSize := 250 // default value + if val, ok := options["engineSize"]; ok { + if engineSizeVal, ok := val.(int); ok { + engineSize = engineSizeVal + } + } + return NewMotorcycle(make, model, year, engineSize) +} + +func (f *MotorcycleFactory) RegisterVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + vehicle := f.CreateVehicle(make, model, year, options) + fmt.Printf("Registering %s\n", vehicle.GetInfo()) + fmt.Println("Assigning license plate to motorcycle") + return vehicle +} + +// TruckFactory is a concrete factory implementation +type TruckFactory struct{} + +func (f *TruckFactory) CreateVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + capacity := 5.0 // default value + if val, ok := options["capacity"]; ok { + if capacityVal, ok := val.(float64); ok { + capacity = capacityVal + } + } + return NewTruck(make, model, year, capacity) +} + +func (f *TruckFactory) RegisterVehicle(make, model string, year int, options map[string]interface{}) Vehicle { + vehicle := f.CreateVehicle(make, model, year, options) + fmt.Printf("Registering %s\n", vehicle.GetInfo()) + fmt.Println("Assigning license plate to truck") + return vehicle +} + +// Abstract Factory Pattern Implementation + +// Engine represents a vehicle engine +type Engine struct { + Type string + Horsepower int +} + +func (e *Engine) GetSpecs() string { + return e.Type + " engine with " + strconv.Itoa(e.Horsepower) + "hp" +} + +// Transmission represents a vehicle transmission +type Transmission struct { + Type string + Gears int +} + +func (t *Transmission) GetSpecs() string { + return t.Type + " transmission with " + strconv.Itoa(t.Gears) + " gears" +} + +// Chassis represents a vehicle chassis +type Chassis struct { + Material string + Weight float64 +} + +func (c *Chassis) GetSpecs() string { + return c.Material + " chassis weighing " + fmt.Sprintf("%.1f", c.Weight) + "kg" +} + +// VehiclePartsFactory is the abstract factory interface +type VehiclePartsFactory interface { + CreateEngine() *Engine + CreateTransmission() *Transmission + CreateChassis() *Chassis +} + +// SportVehiclePartsFactory creates parts for sport vehicles +type SportVehiclePartsFactory struct{} + +func (f *SportVehiclePartsFactory) CreateEngine() *Engine { + return &Engine{Type: "V8", Horsepower: 450} +} + +func (f *SportVehiclePartsFactory) CreateTransmission() *Transmission { + return &Transmission{Type: "Manual", Gears: 6} +} + +func (f *SportVehiclePartsFactory) CreateChassis() *Chassis { + return &Chassis{Material: "Carbon Fiber", Weight: 120.0} +} + +// EconomyVehiclePartsFactory creates parts for economy vehicles +type EconomyVehiclePartsFactory struct{} + +func (f *EconomyVehiclePartsFactory) CreateEngine() *Engine { + return &Engine{Type: "Inline-4", Horsepower: 180} +} + +func (f *EconomyVehiclePartsFactory) CreateTransmission() *Transmission { + return &Transmission{Type: "Automatic", Gears: 5} +} + +func (f *EconomyVehiclePartsFactory) CreateChassis() *Chassis { + return &Chassis{Material: "Steel", Weight: 300.0} +} + +// HeavyDutyVehiclePartsFactory creates parts for heavy duty vehicles +type HeavyDutyVehiclePartsFactory struct{} + +func (f *HeavyDutyVehiclePartsFactory) CreateEngine() *Engine { + return &Engine{Type: "Diesel V6", Horsepower: 350} +} + +func (f *HeavyDutyVehiclePartsFactory) CreateTransmission() *Transmission { + return &Transmission{Type: "Manual", Gears: 8} +} + +func (f *HeavyDutyVehiclePartsFactory) CreateChassis() *Chassis { + return &Chassis{Material: "Reinforced Steel", Weight: 800.0} +} + +// VehicleAssembler uses the abstract factory to assemble vehicles +type VehicleAssembler struct { + PartsFactory VehiclePartsFactory +} + +func NewVehicleAssembler(factory VehiclePartsFactory) *VehicleAssembler { + return &VehicleAssembler{PartsFactory: factory} +} + +func (a *VehicleAssembler) AssembleVehicle() { + engine := a.PartsFactory.CreateEngine() + transmission := a.PartsFactory.CreateTransmission() + chassis := a.PartsFactory.CreateChassis() + + fmt.Println("Assembling vehicle with:") + fmt.Println("- " + engine.GetSpecs()) + fmt.Println("- " + transmission.GetSpecs()) + fmt.Println("- " + chassis.GetSpecs()) +} + +// Example client code +func clientCode() { + fmt.Println("===== Simple Factory Pattern =====") + + factory := &SimpleVehicleFactory{} + + car, _ := factory.CreateVehicle(CarType, "Toyota", "Camry", 2023, map[string]interface{}{"doors": 4}) + motorcycle, _ := factory.CreateVehicle(MotorcycleType, "Honda", "CBR", 2023, map[string]interface{}{"engineSize": 600}) + truck, _ := factory.CreateVehicle(TruckType, "Ford", "F-150", 2023, map[string]interface{}{"capacity": 3.0}) + + fmt.Println(car.GetInfo()) + fmt.Println(car.(*Car).Drive()) + + fmt.Println(motorcycle.GetInfo()) + fmt.Println(motorcycle.(*Motorcycle).Ride()) + + fmt.Println(truck.GetInfo()) + fmt.Println(truck.(*Truck).Haul()) + + fmt.Println("\n===== Factory Method Pattern =====") + + carFactory := &CarFactory{} + motorcycleFactory := &MotorcycleFactory{} + truckFactory := &TruckFactory{} + + newCar := carFactory.RegisterVehicle("BMW", "3 Series", 2023, map[string]interface{}{"doors": 2}) + newMotorcycle := motorcycleFactory.RegisterVehicle("Ducati", "Monster", 2023, map[string]interface{}{"engineSize": 821}) + newTruck := truckFactory.RegisterVehicle("Volvo", "VNL", 2023, map[string]interface{}{"capacity": 20.0}) + + fmt.Println(newCar.(*Car).Drive()) + fmt.Println(newMotorcycle.(*Motorcycle).Ride()) + fmt.Println(newTruck.(*Truck).Haul()) + + fmt.Println("\n===== Abstract Factory Pattern =====") + + sportFactory := &SportVehiclePartsFactory{} + economyFactory := &EconomyVehiclePartsFactory{} + heavyDutyFactory := &HeavyDutyVehiclePartsFactory{} + + fmt.Println("Building a sports car:") + sportAssembler := NewVehicleAssembler(sportFactory) + sportAssembler.AssembleVehicle() + + fmt.Println("\nBuilding an economy car:") + economyAssembler := NewVehicleAssembler(economyFactory) + economyAssembler.AssembleVehicle() + + fmt.Println("\nBuilding a heavy duty truck:") + heavyDutyAssembler := NewVehicleAssembler(heavyDutyFactory) + heavyDutyAssembler.AssembleVehicle() +} + +func main() { + // Run the example + clientCode() +} diff --git a/snippets/design-patterns/factory/factory_pattern.js b/snippets/design-patterns/factory/factory_pattern.js new file mode 100644 index 0000000..b345a1d --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.js @@ -0,0 +1,328 @@ +/** + * Factory Pattern Implementation in JavaScript + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + */ + +// Abstract Product - Vehicle +class Vehicle { + constructor(make, model, year) { + this.make = make; + this.model = model; + this.year = year; + } + + getInfo() { + return `${this.year} ${this.make} ${this.model}`; + } + + start() { + return `${this.getInfo()} is starting...`; + } + + stop() { + return `${this.getInfo()} is stopping...`; + } +} + +// Concrete Products +class Car extends Vehicle { + constructor(make, model, year, doors = 4) { + super(make, model, year); + this.doors = doors; + this.type = 'Car'; + } + + getInfo() { + return `${super.getInfo()} (${this.doors}-door car)`; + } + + drive() { + return `${this.getInfo()} is driving on the road.`; + } +} + +class Motorcycle extends Vehicle { + constructor(make, model, year, engineSize) { + super(make, model, year); + this.engineSize = engineSize; + this.type = 'Motorcycle'; + } + + getInfo() { + return `${super.getInfo()} (${this.engineSize}cc motorcycle)`; + } + + ride() { + return `${this.getInfo()} is riding at high speed.`; + } +} + +class Truck extends Vehicle { + constructor(make, model, year, capacity) { + super(make, model, year); + this.capacity = capacity; + this.type = 'Truck'; + } + + getInfo() { + return `${super.getInfo()} (${this.capacity} ton truck)`; + } + + haul() { + return `${this.getInfo()} is hauling cargo.`; + } +} + +// Simple Factory +class VehicleFactory { + static createVehicle(type, make, model, year, options = {}) { + switch (type.toLowerCase()) { + case 'car': + return new Car(make, model, year, options.doors); + case 'motorcycle': + return new Motorcycle(make, model, year, options.engineSize); + case 'truck': + return new Truck(make, model, year, options.capacity); + default: + throw new Error(`Vehicle type ${type} is not supported.`); + } + } +} + +// Factory Method Pattern Implementation +class VehicleFactoryMethod { + createVehicle(make, model, year, options = {}) { + // This method will be implemented by concrete factories + throw new Error('createVehicle method must be implemented by subclasses'); + } + + registerVehicle(make, model, year, options = {}) { + // Common operations for all vehicles + const vehicle = this.createVehicle(make, model, year, options); + console.log(`Registering ${vehicle.getInfo()}`); + console.log(`Assigning license plate to ${vehicle.type}`); + return vehicle; + } +} + +// Concrete Factories +class CarFactory extends VehicleFactoryMethod { + createVehicle(make, model, year, options = {}) { + return new Car(make, model, year, options.doors || 4); + } +} + +class MotorcycleFactory extends VehicleFactoryMethod { + createVehicle(make, model, year, options = {}) { + return new Motorcycle(make, model, year, options.engineSize || 250); + } +} + +class TruckFactory extends VehicleFactoryMethod { + createVehicle(make, model, year, options = {}) { + return new Truck(make, model, year, options.capacity || 5); + } +} + +// Abstract Factory Pattern Implementation +class VehiclePartsFactory { + createEngine() { + throw new Error('Method not implemented'); + } + + createTransmission() { + throw new Error('Method not implemented'); + } + + createChassis() { + throw new Error('Method not implemented'); + } +} + +// Parts +class Engine { + constructor(type, horsepower) { + this.type = type; + this.horsepower = horsepower; + } + + getSpecs() { + return `${this.type} engine with ${this.horsepower}hp`; + } +} + +class Transmission { + constructor(type, gears) { + this.type = type; + this.gears = gears; + } + + getSpecs() { + return `${this.type} transmission with ${this.gears} gears`; + } +} + +class Chassis { + constructor(material, weight) { + this.material = material; + this.weight = weight; + } + + getSpecs() { + return `${this.material} chassis weighing ${this.weight}kg`; + } +} + +// Concrete Abstract Factories +class SportVehiclePartsFactory extends VehiclePartsFactory { + createEngine() { + return new Engine('V8', 450); + } + + createTransmission() { + return new Transmission('Manual', 6); + } + + createChassis() { + return new Chassis('Carbon Fiber', 120); + } +} + +class EconomyVehiclePartsFactory extends VehiclePartsFactory { + createEngine() { + return new Engine('Inline-4', 180); + } + + createTransmission() { + return new Transmission('Automatic', 5); + } + + createChassis() { + return new Chassis('Steel', 300); + } +} + +class HeavyDutyVehiclePartsFactory extends VehiclePartsFactory { + createEngine() { + return new Engine('Diesel V6', 350); + } + + createTransmission() { + return new Transmission('Manual', 8); + } + + createChassis() { + return new Chassis('Reinforced Steel', 800); + } +} + +// Vehicle Assembler - Uses the Abstract Factory +class VehicleAssembler { + constructor(partsFactory) { + this.partsFactory = partsFactory; + } + + assembleVehicle() { + const engine = this.partsFactory.createEngine(); + const transmission = this.partsFactory.createTransmission(); + const chassis = this.partsFactory.createChassis(); + + console.log('Assembling vehicle with:'); + console.log(`- ${engine.getSpecs()}`); + console.log(`- ${transmission.getSpecs()}`); + console.log(`- ${chassis.getSpecs()}`); + + return { + engine, + transmission, + chassis + }; + } +} + +// Client code demonstration +function clientCode() { + console.log('===== Simple Factory Pattern ====='); + + const car = VehicleFactory.createVehicle('car', 'Toyota', 'Camry', 2023, { doors: 4 }); + const motorcycle = VehicleFactory.createVehicle('motorcycle', 'Honda', 'CBR', 2023, { engineSize: 600 }); + const truck = VehicleFactory.createVehicle('truck', 'Ford', 'F-150', 2023, { capacity: 3 }); + + console.log(car.getInfo()); + console.log(car.drive()); + + console.log(motorcycle.getInfo()); + console.log(motorcycle.ride()); + + console.log(truck.getInfo()); + console.log(truck.haul()); + + console.log('\n===== Factory Method Pattern ====='); + + const carFactory = new CarFactory(); + const motorcycleFactory = new MotorcycleFactory(); + const truckFactory = new TruckFactory(); + + const newCar = carFactory.registerVehicle('BMW', '3 Series', 2023, { doors: 2 }); + const newMotorcycle = motorcycleFactory.registerVehicle('Ducati', 'Monster', 2023, { engineSize: 821 }); + const newTruck = truckFactory.registerVehicle('Volvo', 'VNL', 2023, { capacity: 20 }); + + console.log(newCar.drive()); + console.log(newMotorcycle.ride()); + console.log(newTruck.haul()); + + console.log('\n===== Abstract Factory Pattern ====='); + + const sportPartsFactory = new SportVehiclePartsFactory(); + const economyPartsFactory = new EconomyVehiclePartsFactory(); + const heavyDutyPartsFactory = new HeavyDutyVehiclePartsFactory(); + + console.log('Building a sports car:'); + const sportCarAssembler = new VehicleAssembler(sportPartsFactory); + const sportCarParts = sportCarAssembler.assembleVehicle(); + + console.log('\nBuilding an economy car:'); + const economyCarAssembler = new VehicleAssembler(economyPartsFactory); + const economyCarParts = economyCarAssembler.assembleVehicle(); + + console.log('\nBuilding a heavy duty truck:'); + const heavyDutyTruckAssembler = new VehicleAssembler(heavyDutyPartsFactory); + const heavyDutyTruckParts = heavyDutyTruckAssembler.assembleVehicle(); +} + +// Execute the client code +// Run the example +clientCode(); + +// Export classes for use in other modules +module.exports = { + // Simple Factory + VehicleFactory, + + // Factory Method + VehicleFactoryMethod, + CarFactory, + MotorcycleFactory, + TruckFactory, + + // Abstract Factory + VehiclePartsFactory, + SportVehiclePartsFactory, + EconomyVehiclePartsFactory, + HeavyDutyVehiclePartsFactory, + VehicleAssembler, + + // Products + Vehicle, + Car, + Motorcycle, + Truck, + Engine, + Transmission, + Chassis +}; diff --git a/snippets/design-patterns/factory/factory_pattern.php b/snippets/design-patterns/factory/factory_pattern.php new file mode 100644 index 0000000..1c1f422 --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.php @@ -0,0 +1,308 @@ +make = $make; + $this->model = $model; + $this->year = $year; + } + + public function getInfo() { + return "{$this->year} {$this->make} {$this->model}"; + } + + public function start() { + return $this->getInfo() . " is starting..."; + } + + public function stop() { + return $this->getInfo() . " is stopping..."; + } +} + +// Concrete Products +class Car extends Vehicle { + protected $doors; + + public function __construct($make, $model, $year, $doors = 4) { + parent::__construct($make, $model, $year); + $this->doors = $doors; + } + + public function getInfo() { + return parent::getInfo() . " ({$this->doors}-door car)"; + } + + public function drive() { + return $this->getInfo() . " is driving on the road."; + } +} + +class Motorcycle extends Vehicle { + protected $engineSize; + + public function __construct($make, $model, $year, $engineSize) { + parent::__construct($make, $model, $year); + $this->engineSize = $engineSize; + } + + public function getInfo() { + return parent::getInfo() . " ({$this->engineSize}cc motorcycle)"; + } + + public function ride() { + return $this->getInfo() . " is riding at high speed."; + } +} + +class Truck extends Vehicle { + protected $capacity; + + public function __construct($make, $model, $year, $capacity) { + parent::__construct($make, $model, $year); + $this->capacity = $capacity; + } + + public function getInfo() { + return parent::getInfo() . " ({$this->capacity} ton truck)"; + } + + public function haul() { + return $this->getInfo() . " is hauling cargo."; + } +} + +// Simple Factory +class VehicleFactory { + const CAR = 'car'; + const MOTORCYCLE = 'motorcycle'; + const TRUCK = 'truck'; + + public static function createVehicle($type, $make, $model, $year, $options = []) { + switch (strtolower($type)) { + case self::CAR: + $doors = isset($options['doors']) ? $options['doors'] : 4; + return new Car($make, $model, $year, $doors); + case self::MOTORCYCLE: + $engineSize = isset($options['engineSize']) ? $options['engineSize'] : 250; + return new Motorcycle($make, $model, $year, $engineSize); + case self::TRUCK: + $capacity = isset($options['capacity']) ? $options['capacity'] : 5.0; + return new Truck($make, $model, $year, $capacity); + default: + throw new Exception("Vehicle type {$type} is not supported."); + } + } +} + +// Factory Method Pattern Implementation +abstract class VehicleFactoryMethod { + abstract public function createVehicle($make, $model, $year, $options = []); + + public function registerVehicle($make, $model, $year, $options = []) { + // Common operations for all vehicles + $vehicle = $this->createVehicle($make, $model, $year, $options); + echo "Registering " . $vehicle->getInfo() . PHP_EOL; + echo "Assigning license plate" . PHP_EOL; + return $vehicle; + } +} + +// Concrete Factories +class CarFactory extends VehicleFactoryMethod { + public function createVehicle($make, $model, $year, $options = []) { + $doors = isset($options['doors']) ? $options['doors'] : 4; + return new Car($make, $model, $year, $doors); + } +} + +class MotorcycleFactory extends VehicleFactoryMethod { + public function createVehicle($make, $model, $year, $options = []) { + $engineSize = isset($options['engineSize']) ? $options['engineSize'] : 250; + return new Motorcycle($make, $model, $year, $engineSize); + } +} + +class TruckFactory extends VehicleFactoryMethod { + public function createVehicle($make, $model, $year, $options = []) { + $capacity = isset($options['capacity']) ? $options['capacity'] : 5.0; + return new Truck($make, $model, $year, $capacity); + } +} + +// Abstract Factory Pattern Implementation +// Parts +class Engine { + protected $type; + protected $horsepower; + + public function __construct($type, $horsepower) { + $this->type = $type; + $this->horsepower = $horsepower; + } + + public function getSpecs() { + return "{$this->type} engine with {$this->horsepower}hp"; + } +} + +class Transmission { + protected $type; + protected $gears; + + public function __construct($type, $gears) { + $this->type = $type; + $this->gears = $gears; + } + + public function getSpecs() { + return "{$this->type} transmission with {$this->gears} gears"; + } +} + +class Chassis { + protected $material; + protected $weight; + + public function __construct($material, $weight) { + $this->material = $material; + $this->weight = $weight; + } + + public function getSpecs() { + return "{$this->material} chassis weighing {$this->weight}kg"; + } +} + +// Abstract Factory +interface VehiclePartsFactory { + public function createEngine(); + public function createTransmission(); + public function createChassis(); +} + +// Concrete Abstract Factories +class SportVehiclePartsFactory implements VehiclePartsFactory { + public function createEngine() { + return new Engine("V8", 450); + } + + public function createTransmission() { + return new Transmission("Manual", 6); + } + + public function createChassis() { + return new Chassis("Carbon Fiber", 120); + } +} + +class EconomyVehiclePartsFactory implements VehiclePartsFactory { + public function createEngine() { + return new Engine("Inline-4", 180); + } + + public function createTransmission() { + return new Transmission("Automatic", 5); + } + + public function createChassis() { + return new Chassis("Steel", 300); + } +} + +class HeavyDutyVehiclePartsFactory implements VehiclePartsFactory { + public function createEngine() { + return new Engine("Diesel V6", 350); + } + + public function createTransmission() { + return new Transmission("Manual", 8); + } + + public function createChassis() { + return new Chassis("Reinforced Steel", 800); + } +} + +// Vehicle Assembler - Uses the Abstract Factory +class VehicleAssembler { + protected $partsFactory; + + public function __construct(VehiclePartsFactory $partsFactory) { + $this->partsFactory = $partsFactory; + } + + public function assembleVehicle() { + $engine = $this->partsFactory->createEngine(); + $transmission = $this->partsFactory->createTransmission(); + $chassis = $this->partsFactory->createChassis(); + + echo "Assembling vehicle with:" . PHP_EOL; + echo "- " . $engine->getSpecs() . PHP_EOL; + echo "- " . $transmission->getSpecs() . PHP_EOL; + echo "- " . $chassis->getSpecs() . PHP_EOL; + } +} + +// Client code demonstration +function clientCode() { + echo "===== Simple Factory Pattern =====" . PHP_EOL; + + $car = VehicleFactory::createVehicle(VehicleFactory::CAR, "Toyota", "Camry", 2023, ['doors' => 4]); + $motorcycle = VehicleFactory::createVehicle(VehicleFactory::MOTORCYCLE, "Honda", "CBR", 2023, ['engineSize' => 600]); + $truck = VehicleFactory::createVehicle(VehicleFactory::TRUCK, "Ford", "F-150", 2023, ['capacity' => 3.0]); + + echo $car->getInfo() . PHP_EOL; + echo $car->drive() . PHP_EOL; + + echo $motorcycle->getInfo() . PHP_EOL; + echo $motorcycle->ride() . PHP_EOL; + + echo $truck->getInfo() . PHP_EOL; + echo $truck->haul() . PHP_EOL; + + echo PHP_EOL . "===== Factory Method Pattern =====" . PHP_EOL; + + $carFactory = new CarFactory(); + $motorcycleFactory = new MotorcycleFactory(); + $truckFactory = new TruckFactory(); + + $newCar = $carFactory->registerVehicle("BMW", "3 Series", 2023, ['doors' => 2]); + $newMotorcycle = $motorcycleFactory->registerVehicle("Ducati", "Monster", 2023, ['engineSize' => 821]); + $newTruck = $truckFactory->registerVehicle("Volvo", "VNL", 2023, ['capacity' => 20.0]); + + echo $newCar->drive() . PHP_EOL; + echo $newMotorcycle->ride() . PHP_EOL; + echo $newTruck->haul() . PHP_EOL; + + echo PHP_EOL . "===== Abstract Factory Pattern =====" . PHP_EOL; + + echo "Building a sports car:" . PHP_EOL; + $sportCarAssembler = new VehicleAssembler(new SportVehiclePartsFactory()); + $sportCarAssembler->assembleVehicle(); + + echo PHP_EOL . "Building an economy car:" . PHP_EOL; + $economyCarAssembler = new VehicleAssembler(new EconomyVehiclePartsFactory()); + $economyCarAssembler->assembleVehicle(); + + echo PHP_EOL . "Building a heavy duty truck:" . PHP_EOL; + $heavyDutyTruckAssembler = new VehicleAssembler(new HeavyDutyVehiclePartsFactory()); + $heavyDutyTruckAssembler->assembleVehicle(); +} + +// Run the example +clientCode(); diff --git a/snippets/design-patterns/factory/factory_pattern.py b/snippets/design-patterns/factory/factory_pattern.py new file mode 100644 index 0000000..70b01e0 --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python3 +""" +Factory Pattern Implementation in Python + +This demonstrates three variations of the Factory Pattern: +1. Simple Factory +2. Factory Method +3. Abstract Factory +""" + +from abc import ABC, abstractmethod +import sys + +# ============= SIMPLE FACTORY EXAMPLE ============= + +class Product(ABC): + """Product interface""" + @abstractmethod + def operation(self): + pass + +class ConcreteProductA(Product): + """Concrete product A""" + def operation(self): + return "Result of ConcreteProductA operation" + +class ConcreteProductB(Product): + """Concrete product B""" + def operation(self): + return "Result of ConcreteProductB operation" + +class SimpleFactory: + """Simple Factory implementation""" + @staticmethod + def create_product(product_type): + """Creates a product based on type""" + if product_type == "A": + return ConcreteProductA() + elif product_type == "B": + return ConcreteProductB() + else: + raise ValueError(f"Product type {product_type} not recognized") + +# Client code for Simple Factory +def simple_factory_client(): + """Demo of Simple Factory Pattern""" + print("\n=== Simple Factory Example ===") + factory = SimpleFactory() + + # Create and use product A + product_a = factory.create_product("A") + print(product_a.operation()) + + # Create and use product B + product_b = factory.create_product("B") + print(product_b.operation()) + +# ============= FACTORY METHOD EXAMPLE ============= + +class Creator(ABC): + """Creator class with factory method""" + @abstractmethod + def factory_method(self): + """Factory method to be implemented by subclasses""" + pass + + def some_operation(self): + """Business logic that uses the factory method""" + # Call the factory method to create a Product object + product = self.factory_method() + + # Use the product + result = f"Creator: The same creator's code has just worked with {product.operation()}" + return result + +class ConcreteCreator1(Creator): + """Concrete creator that returns ConcreteProductA""" + def factory_method(self): + return ConcreteProductA() + +class ConcreteCreator2(Creator): + """Concrete creator that returns ConcreteProductB""" + def factory_method(self): + return ConcreteProductB() + +# Client code for Factory Method +def factory_method_client(): + """Demo of Factory Method Pattern""" + print("\n=== Factory Method Example ===") + + print("App: Launched with ConcreteCreator1") + client_code(ConcreteCreator1()) + + print("\nApp: Launched with ConcreteCreator2") + client_code(ConcreteCreator2()) + +def client_code(creator): + """Client code that works with any creator subclass""" + print(f"Client: I'm not aware of the creator's class, but it still works.\n" + f"{creator.some_operation()}") + +# ============= ABSTRACT FACTORY EXAMPLE ============= + +class AbstractProductA(ABC): + """Abstract product A interface""" + @abstractmethod + def useful_function_a(self): + pass + +class ConcreteProductA1(AbstractProductA): + """Concrete product A1 - Family 1""" + def useful_function_a(self): + return "The result of the product A1." + +class ConcreteProductA2(AbstractProductA): + """Concrete product A2 - Family 2""" + def useful_function_a(self): + return "The result of the product A2." + +class AbstractProductB(ABC): + """Abstract product B interface""" + @abstractmethod + def useful_function_b(self): + pass + + @abstractmethod + def another_useful_function_b(self, collaborator: AbstractProductA): + """ + B products can work with A products + """ + pass + +class ConcreteProductB1(AbstractProductB): + """Concrete product B1 - Family 1""" + def useful_function_b(self): + return "The result of the product B1." + + def another_useful_function_b(self, collaborator: AbstractProductA): + result = collaborator.useful_function_a() + return f"The result of B1 collaborating with ({result})" + +class ConcreteProductB2(AbstractProductB): + """Concrete product B2 - Family 2""" + def useful_function_b(self): + return "The result of the product B2." + + def another_useful_function_b(self, collaborator: AbstractProductA): + result = collaborator.useful_function_a() + return f"The result of B2 collaborating with ({result})" + +class AbstractFactory(ABC): + """Abstract Factory Interface""" + @abstractmethod + def create_product_a(self) -> AbstractProductA: + pass + + @abstractmethod + def create_product_b(self) -> AbstractProductB: + pass + +class ConcreteFactory1(AbstractFactory): + """Concrete Factory for Family 1 products""" + def create_product_a(self) -> AbstractProductA: + return ConcreteProductA1() + + def create_product_b(self) -> AbstractProductB: + return ConcreteProductB1() + +class ConcreteFactory2(AbstractFactory): + """Concrete Factory for Family 2 products""" + def create_product_a(self) -> AbstractProductA: + return ConcreteProductA2() + + def create_product_b(self) -> AbstractProductB: + return ConcreteProductB2() + +def abstract_factory_client(): + """Demo of Abstract Factory Pattern""" + print("\n=== Abstract Factory Example ===") + + print("Client: Testing client code with the first factory type:") + client_abstract_factory_code(ConcreteFactory1()) + + print("\nClient: Testing the same client code with the second factory type:") + client_abstract_factory_code(ConcreteFactory2()) + +def client_abstract_factory_code(factory: AbstractFactory): + """ + Client code that works with factories and products through abstract interfaces + """ + product_a = factory.create_product_a() + product_b = factory.create_product_b() + + print(f"{product_b.useful_function_b()}") + print(f"{product_b.another_useful_function_b(product_a)}") + + +# ============= REAL-WORLD EXAMPLE: UI COMPONENTS ============= + +# Abstract products +class Button(ABC): + @abstractmethod + def render(self): + pass + + @abstractmethod + def on_click(self): + pass + +class Checkbox(ABC): + @abstractmethod + def render(self): + pass + + @abstractmethod + def toggle(self): + pass + +# Concrete products for Windows +class WindowsButton(Button): + def render(self): + return "Rendering a Windows button" + + def on_click(self): + return "Windows button clicked!" + +class WindowsCheckbox(Checkbox): + def render(self): + return "Rendering a Windows checkbox" + + def toggle(self): + return "Windows checkbox toggled!" + +# Concrete products for Web +class WebButton(Button): + def render(self): + return "Rendering a button in HTML" + + def on_click(self): + return "JavaScript click event triggered!" + +class WebCheckbox(Checkbox): + def render(self): + return "Rendering a checkbox in HTML" + + def toggle(self): + return "JavaScript toggle event triggered!" + +# Abstract factory +class GUIFactory(ABC): + @abstractmethod + def create_button(self) -> Button: + pass + + @abstractmethod + def create_checkbox(self) -> Checkbox: + pass + +# Concrete factories +class WindowsFactory(GUIFactory): + def create_button(self) -> Button: + return WindowsButton() + + def create_checkbox(self) -> Checkbox: + return WindowsCheckbox() + +class WebFactory(GUIFactory): + def create_button(self) -> Button: + return WebButton() + + def create_checkbox(self) -> Checkbox: + return WebCheckbox() + +# Client code +class Application: + def __init__(self, factory: GUIFactory): + self._factory = factory + self._button = None + self._checkbox = None + + def create_ui(self): + self._button = self._factory.create_button() + self._checkbox = self._factory.create_checkbox() + + print("Creating UI:") + print(self._button.render()) + print(self._checkbox.render()) + + def click_button(self): + print(self._button.on_click()) + + def toggle_checkbox(self): + print(self._checkbox.toggle()) + +def real_world_example(): + """Demo of a real-world Abstract Factory example""" + print("\n=== Real-World UI Factory Example ===") + + # Determine which factory to use based on configuration or environment + if sys.platform.startswith('win'): + print("\nRunning on Windows, using Windows UI components") + factory = WindowsFactory() + else: + print("\nRunning on a non-Windows platform, using Web UI components") + factory = WebFactory() + + # Create and use the application + app = Application(factory) + app.create_ui() + app.click_button() + app.toggle_checkbox() + + +if __name__ == "__main__": + print("Factory Pattern Demonstrations") + print("==============================") + + # Run the Simple Factory example + simple_factory_client() + + # Run the Factory Method example + factory_method_client() + + # Run the Abstract Factory example + abstract_factory_client() + + # Run the real-world example + real_world_example() \ No newline at end of file diff --git a/snippets/design-patterns/factory/factory_pattern.rb b/snippets/design-patterns/factory/factory_pattern.rb new file mode 100644 index 0000000..fd4d232 --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.rb @@ -0,0 +1,310 @@ +#!/usr/bin/env ruby + +# Factory Pattern Implementation in Ruby +# +# The Factory Pattern is a creational design pattern that provides an interface for creating +# objects in a superclass, but allows subclasses to alter the type of objects that will be created. +# +# This example demonstrates a Vehicle Factory that can create different types of vehicles +# (Car, Motorcycle, Truck) based on the client's requirements. + +# Abstract Product - Vehicle +class Vehicle + attr_reader :make, :model, :year + + def initialize(make, model, year) + @make = make + @model = model + @year = year + end + + def get_info + "#{@year} #{@make} #{@model}" + end + + def start + "#{get_info} is starting..." + end + + def stop + "#{get_info} is stopping..." + end +end + +# Concrete Products +class Car < Vehicle + attr_reader :doors + + def initialize(make, model, year, doors = 4) + super(make, model, year) + @doors = doors + end + + def get_info + "#{super} (#{@doors}-door car)" + end + + def drive + "#{get_info} is driving on the road." + end +end + +class Motorcycle < Vehicle + attr_reader :engine_size + + def initialize(make, model, year, engine_size) + super(make, model, year) + @engine_size = engine_size + end + + def get_info + "#{super} (#{@engine_size}cc motorcycle)" + end + + def ride + "#{get_info} is riding at high speed." + end +end + +class Truck < Vehicle + attr_reader :capacity + + def initialize(make, model, year, capacity) + super(make, model, year) + @capacity = capacity + end + + def get_info + "#{super} (#{@capacity} ton truck)" + end + + def haul + "#{get_info} is hauling cargo." + end +end + +# Simple Factory +class VehicleFactory + CAR = 'car' + MOTORCYCLE = 'motorcycle' + TRUCK = 'truck' + + def self.create_vehicle(type, make, model, year, options = {}) + case type.downcase + when CAR + doors = options[:doors] || 4 + Car.new(make, model, year, doors) + when MOTORCYCLE + engine_size = options[:engine_size] || 250 + Motorcycle.new(make, model, year, engine_size) + when TRUCK + capacity = options[:capacity] || 5.0 + Truck.new(make, model, year, capacity) + else + raise "Vehicle type #{type} is not supported." + end + end +end + +# Factory Method Pattern Implementation +class VehicleFactoryMethod + def create_vehicle(make, model, year, options = {}) + raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" + end + + def register_vehicle(make, model, year, options = {}) + # Common operations for all vehicles + vehicle = create_vehicle(make, model, year, options) + puts "Registering #{vehicle.get_info}" + puts "Assigning license plate" + vehicle + end +end + +# Concrete Factories +class CarFactory < VehicleFactoryMethod + def create_vehicle(make, model, year, options = {}) + doors = options[:doors] || 4 + Car.new(make, model, year, doors) + end +end + +class MotorcycleFactory < VehicleFactoryMethod + def create_vehicle(make, model, year, options = {}) + engine_size = options[:engine_size] || 250 + Motorcycle.new(make, model, year, engine_size) + end +end + +class TruckFactory < VehicleFactoryMethod + def create_vehicle(make, model, year, options = {}) + capacity = options[:capacity] || 5.0 + Truck.new(make, model, year, capacity) + end +end + +# Abstract Factory Pattern Implementation +# Parts +class Engine + attr_reader :type, :horsepower + + def initialize(type, horsepower) + @type = type + @horsepower = horsepower + end + + def get_specs + "#{@type} engine with #{@horsepower}hp" + end +end + +class Transmission + attr_reader :type, :gears + + def initialize(type, gears) + @type = type + @gears = gears + end + + def get_specs + "#{@type} transmission with #{@gears} gears" + end +end + +class Chassis + attr_reader :material, :weight + + def initialize(material, weight) + @material = material + @weight = weight + end + + def get_specs + "#{@material} chassis weighing #{@weight}kg" + end +end + +# Abstract Factory +class VehiclePartsFactory + def create_engine + raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" + end + + def create_transmission + raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" + end + + def create_chassis + raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" + end +end + +# Concrete Abstract Factories +class SportVehiclePartsFactory < VehiclePartsFactory + def create_engine + Engine.new("V8", 450) + end + + def create_transmission + Transmission.new("Manual", 6) + end + + def create_chassis + Chassis.new("Carbon Fiber", 120) + end +end + +class EconomyVehiclePartsFactory < VehiclePartsFactory + def create_engine + Engine.new("Inline-4", 180) + end + + def create_transmission + Transmission.new("Automatic", 5) + end + + def create_chassis + Chassis.new("Steel", 300) + end +end + +class HeavyDutyVehiclePartsFactory < VehiclePartsFactory + def create_engine + Engine.new("Diesel V6", 350) + end + + def create_transmission + Transmission.new("Manual", 8) + end + + def create_chassis + Chassis.new("Reinforced Steel", 800) + end +end + +# Vehicle Assembler - Uses the Abstract Factory +class VehicleAssembler + def initialize(parts_factory) + @parts_factory = parts_factory + end + + def assemble_vehicle + engine = @parts_factory.create_engine + transmission = @parts_factory.create_transmission + chassis = @parts_factory.create_chassis + + puts "Assembling vehicle with:" + puts "- #{engine.get_specs}" + puts "- #{transmission.get_specs}" + puts "- #{chassis.get_specs}" + end +end + +# Client code demonstration +def client_code + puts "===== Simple Factory Pattern =====" + + car = VehicleFactory.create_vehicle(VehicleFactory::CAR, "Toyota", "Camry", 2023, { doors: 4 }) + motorcycle = VehicleFactory.create_vehicle(VehicleFactory::MOTORCYCLE, "Honda", "CBR", 2023, { engine_size: 600 }) + truck = VehicleFactory.create_vehicle(VehicleFactory::TRUCK, "Ford", "F-150", 2023, { capacity: 3.0 }) + + puts car.get_info + puts car.drive + + puts motorcycle.get_info + puts motorcycle.ride + + puts truck.get_info + puts truck.haul + + puts "\n===== Factory Method Pattern =====" + + car_factory = CarFactory.new + motorcycle_factory = MotorcycleFactory.new + truck_factory = TruckFactory.new + + new_car = car_factory.register_vehicle("BMW", "3 Series", 2023, { doors: 2 }) + new_motorcycle = motorcycle_factory.register_vehicle("Ducati", "Monster", 2023, { engine_size: 821 }) + new_truck = truck_factory.register_vehicle("Volvo", "VNL", 2023, { capacity: 20.0 }) + + puts new_car.drive + puts new_motorcycle.ride + puts new_truck.haul + + puts "\n===== Abstract Factory Pattern =====" + + puts "Building a sports car:" + sport_car_assembler = VehicleAssembler.new(SportVehiclePartsFactory.new) + sport_car_assembler.assemble_vehicle + + puts "\nBuilding an economy car:" + economy_car_assembler = VehicleAssembler.new(EconomyVehiclePartsFactory.new) + economy_car_assembler.assemble_vehicle + + puts "\nBuilding a heavy duty truck:" + heavy_duty_truck_assembler = VehicleAssembler.new(HeavyDutyVehiclePartsFactory.new) + heavy_duty_truck_assembler.assemble_vehicle +end + +# Run the example +client_code diff --git a/snippets/design-patterns/factory/factory_pattern.rs b/snippets/design-patterns/factory/factory_pattern.rs new file mode 100644 index 0000000..cf0b45c --- /dev/null +++ b/snippets/design-patterns/factory/factory_pattern.rs @@ -0,0 +1,447 @@ +/** + * Factory Pattern Implementation in Rust + * + * The Factory Pattern is a creational design pattern that provides an interface for creating + * objects in a superclass, but allows subclasses to alter the type of objects that will be created. + * + * This example demonstrates a Vehicle Factory that can create different types of vehicles + * (Car, Motorcycle, Truck) based on the client's requirements. + */ + +use std::fmt; + +// Abstract Product - Vehicle Trait +trait Vehicle { + fn get_info(&self) -> String; + fn start(&self) -> String { + format!("{} is starting...", self.get_info()) + } + fn stop(&self) -> String { + format!("{} is stopping...", self.get_info()) + } +} + +// Concrete Products +struct Car { + make: String, + model: String, + year: u32, + doors: u32, +} + +impl Car { + fn new(make: &str, model: &str, year: u32, doors: u32) -> Self { + Car { + make: make.to_string(), + model: model.to_string(), + year, + doors, + } + } + + fn drive(&self) -> String { + format!("{} is driving on the road.", self.get_info()) + } +} + +impl Vehicle for Car { + fn get_info(&self) -> String { + format!("{} {} {} ({}-door car)", self.year, self.make, self.model, self.doors) + } +} + +struct Motorcycle { + make: String, + model: String, + year: u32, + engine_size: u32, +} + +impl Motorcycle { + fn new(make: &str, model: &str, year: u32, engine_size: u32) -> Self { + Motorcycle { + make: make.to_string(), + model: model.to_string(), + year, + engine_size, + } + } + + fn ride(&self) -> String { + format!("{} is riding at high speed.", self.get_info()) + } +} + +impl Vehicle for Motorcycle { + fn get_info(&self) -> String { + format!( + "{} {} {} ({}cc motorcycle)", + self.year, self.make, self.model, self.engine_size + ) + } +} + +struct Truck { + make: String, + model: String, + year: u32, + capacity: f64, +} + +impl Truck { + fn new(make: &str, model: &str, year: u32, capacity: f64) -> Self { + Truck { + make: make.to_string(), + model: model.to_string(), + year, + capacity, + } + } + + fn haul(&self) -> String { + format!("{} is hauling cargo.", self.get_info()) + } +} + +impl Vehicle for Truck { + fn get_info(&self) -> String { + format!( + "{} {} {} ({} ton truck)", + self.year, self.make, self.model, self.capacity + ) + } +} + +// Simple Factory +enum VehicleType { + Car, + Motorcycle, + Truck, +} + +struct VehicleFactory; + +impl VehicleFactory { + fn create_car(make: &str, model: &str, year: u32, doors: u32) -> Box { + Box::new(Car::new(make, model, year, doors)) + } + + fn create_motorcycle(make: &str, model: &str, year: u32, engine_size: u32) -> Box { + Box::new(Motorcycle::new(make, model, year, engine_size)) + } + + fn create_truck(make: &str, model: &str, year: u32, capacity: f64) -> Box { + Box::new(Truck::new(make, model, year, capacity)) + } + + fn create_vehicle( + vehicle_type: VehicleType, + make: &str, + model: &str, + year: u32, + options: &[f64], + ) -> Box { + match vehicle_type { + VehicleType::Car => { + let doors = if options.is_empty() { 4 } else { options[0] as u32 }; + Self::create_car(make, model, year, doors) + } + VehicleType::Motorcycle => { + let engine_size = if options.is_empty() { 250 } else { options[0] as u32 }; + Self::create_motorcycle(make, model, year, engine_size) + } + VehicleType::Truck => { + let capacity = if options.is_empty() { 5.0 } else { options[0] }; + Self::create_truck(make, model, year, capacity) + } + } + } +} + +// Factory Method Pattern Implementation +trait VehicleFactoryMethod { + fn create_vehicle(&self, make: &str, model: &str, year: u32, options: &[f64]) -> Box; + + fn register_vehicle(&self, make: &str, model: &str, year: u32, options: &[f64]) -> Box { + // Common operations for all vehicles + let vehicle = self.create_vehicle(make, model, year, options); + println!("Registering {}", vehicle.get_info()); + println!("Assigning license plate"); + vehicle + } +} + +// Concrete Factories +struct CarFactory; + +impl VehicleFactoryMethod for CarFactory { + fn create_vehicle(&self, make: &str, model: &str, year: u32, options: &[f64]) -> Box { + let doors = if options.is_empty() { 4 } else { options[0] as u32 }; + Box::new(Car::new(make, model, year, doors)) + } +} + +struct MotorcycleFactory; + +impl VehicleFactoryMethod for MotorcycleFactory { + fn create_vehicle(&self, make: &str, model: &str, year: u32, options: &[f64]) -> Box { + let engine_size = if options.is_empty() { 250 } else { options[0] as u32 }; + Box::new(Motorcycle::new(make, model, year, engine_size)) + } +} + +struct TruckFactory; + +impl VehicleFactoryMethod for TruckFactory { + fn create_vehicle(&self, make: &str, model: &str, year: u32, options: &[f64]) -> Box { + let capacity = if options.is_empty() { 5.0 } else { options[0] }; + Box::new(Truck::new(make, model, year, capacity)) + } +} + +// Abstract Factory Pattern Implementation +// Parts +struct Engine { + engine_type: String, + horsepower: u32, +} + +impl Engine { + fn new(engine_type: &str, horsepower: u32) -> Self { + Engine { + engine_type: engine_type.to_string(), + horsepower, + } + } + + fn get_specs(&self) -> String { + format!("{} engine with {}hp", self.engine_type, self.horsepower) + } +} + +struct Transmission { + transmission_type: String, + gears: u32, +} + +impl Transmission { + fn new(transmission_type: &str, gears: u32) -> Self { + Transmission { + transmission_type: transmission_type.to_string(), + gears, + } + } + + fn get_specs(&self) -> String { + format!( + "{} transmission with {} gears", + self.transmission_type, self.gears + ) + } +} + +struct Chassis { + material: String, + weight: f64, +} + +impl Chassis { + fn new(material: &str, weight: f64) -> Self { + Chassis { + material: material.to_string(), + weight, + } + } + + fn get_specs(&self) -> String { + format!("{} chassis weighing {}kg", self.material, self.weight) + } +} + +// Abstract Factory +trait VehiclePartsFactory { + fn create_engine(&self) -> Engine; + fn create_transmission(&self) -> Transmission; + fn create_chassis(&self) -> Chassis; +} + +// Concrete Abstract Factories +struct SportVehiclePartsFactory; + +impl VehiclePartsFactory for SportVehiclePartsFactory { + fn create_engine(&self) -> Engine { + Engine::new("V8", 450) + } + + fn create_transmission(&self) -> Transmission { + Transmission::new("Manual", 6) + } + + fn create_chassis(&self) -> Chassis { + Chassis::new("Carbon Fiber", 120.0) + } +} + +struct EconomyVehiclePartsFactory; + +impl VehiclePartsFactory for EconomyVehiclePartsFactory { + fn create_engine(&self) -> Engine { + Engine::new("Inline-4", 180) + } + + fn create_transmission(&self) -> Transmission { + Transmission::new("Automatic", 5) + } + + fn create_chassis(&self) -> Chassis { + Chassis::new("Steel", 300.0) + } +} + +struct HeavyDutyVehiclePartsFactory; + +impl VehiclePartsFactory for HeavyDutyVehiclePartsFactory { + fn create_engine(&self) -> Engine { + Engine::new("Diesel V6", 350) + } + + fn create_transmission(&self) -> Transmission { + Transmission::new("Manual", 8) + } + + fn create_chassis(&self) -> Chassis { + Chassis::new("Reinforced Steel", 800.0) + } +} + +// Vehicle Assembler - Uses the Abstract Factory +struct VehicleAssembler { + parts_factory: T, +} + +impl VehicleAssembler { + fn new(parts_factory: T) -> Self { + VehicleAssembler { parts_factory } + } + + fn assemble_vehicle(&self) { + let engine = self.parts_factory.create_engine(); + let transmission = self.parts_factory.create_transmission(); + let chassis = self.parts_factory.create_chassis(); + + println!("Assembling vehicle with:"); + println!("- {}", engine.get_specs()); + println!("- {}", transmission.get_specs()); + println!("- {}", chassis.get_specs()); + } +} + +// Client code demonstration +fn client_code() { + println!("===== Simple Factory Pattern ====="); + + let car = VehicleFactory::create_vehicle( + VehicleType::Car, + "Toyota", + "Camry", + 2023, + &[4.0], + ); + let motorcycle = VehicleFactory::create_vehicle( + VehicleType::Motorcycle, + "Honda", + "CBR", + 2023, + &[600.0], + ); + let truck = VehicleFactory::create_vehicle( + VehicleType::Truck, + "Ford", + "F-150", + 2023, + &[3.0], + ); + + println!("{}", car.get_info()); + // We need to downcast to call specific methods + if let Some(car) = car.as_any().downcast_ref::() { + println!("{}", car.drive()); + } + + println!("{}", motorcycle.get_info()); + if let Some(motorcycle) = motorcycle.as_any().downcast_ref::() { + println!("{}", motorcycle.ride()); + } + + println!("{}", truck.get_info()); + if let Some(truck) = truck.as_any().downcast_ref::() { + println!("{}", truck.haul()); + } + + println!("\n===== Factory Method Pattern ====="); + + let car_factory = CarFactory; + let motorcycle_factory = MotorcycleFactory; + let truck_factory = TruckFactory; + + let new_car = car_factory.register_vehicle("BMW", "3 Series", 2023, &[2.0]); + let new_motorcycle = motorcycle_factory.register_vehicle("Ducati", "Monster", 2023, &[821.0]); + let new_truck = truck_factory.register_vehicle("Volvo", "VNL", 2023, &[20.0]); + + if let Some(car) = new_car.as_any().downcast_ref::() { + println!("{}", car.drive()); + } + if let Some(motorcycle) = new_motorcycle.as_any().downcast_ref::() { + println!("{}", motorcycle.ride()); + } + if let Some(truck) = new_truck.as_any().downcast_ref::() { + println!("{}", truck.haul()); + } + + println!("\n===== Abstract Factory Pattern ====="); + + println!("Building a sports car:"); + let sport_car_assembler = VehicleAssembler::new(SportVehiclePartsFactory); + sport_car_assembler.assemble_vehicle(); + + println!("\nBuilding an economy car:"); + let economy_car_assembler = VehicleAssembler::new(EconomyVehiclePartsFactory); + economy_car_assembler.assemble_vehicle(); + + println!("\nBuilding a heavy duty truck:"); + let heavy_duty_truck_assembler = VehicleAssembler::new(HeavyDutyVehiclePartsFactory); + heavy_duty_truck_assembler.assemble_vehicle(); +} + +// Extension trait to allow downcasting +trait AsAny { + fn as_any(&self) -> &dyn std::any::Any; +} + +impl AsAny for T { + fn as_any(&self) -> &dyn std::any::Any { + self + } +} + +// Extend Vehicle trait to include AsAny +trait VehicleExt: Vehicle + AsAny {} + +// Implement VehicleExt for all types that implement Vehicle +impl VehicleExt for T {} + +// Update the Vehicle trait to include AsAny functionality +trait Vehicle: AsAny { + fn get_info(&self) -> String; + fn start(&self) -> String { + format!("{} is starting...", self.get_info()) + } + fn stop(&self) -> String { + format!("{} is stopping...", self.get_info()) + } +} + +fn main() { + // Run the example + client_code(); +} diff --git a/snippets/design-patterns/observer/ObserverPattern.cpp b/snippets/design-patterns/observer/ObserverPattern.cpp new file mode 100644 index 0000000..ea9aa96 --- /dev/null +++ b/snippets/design-patterns/observer/ObserverPattern.cpp @@ -0,0 +1,363 @@ +#include +#include +#include +#include +#include + +/** + * Observer Design Pattern Implementation in C++ + * + * This demonstrates a weather station example of the Observer pattern. + */ + +// Forward declaration +class Subject; + +// Observer interface +class Observer { +public: + virtual ~Observer() = default; + virtual void update(Subject* subject) = 0; +}; + +// Subject interface +class Subject { +private: + std::vector observers; + +public: + virtual ~Subject() = default; + + void attach(Observer* observer) { + std::cout << "Attaching an observer\n"; + observers.push_back(observer); + } + + void detach(Observer* observer) { + std::cout << "Detaching an observer\n"; + observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end()); + } + + void notify() { + std::cout << "Notifying observers...\n"; + for (Observer* observer : observers) { + observer->update(this); + } + } + + // Subject should provide interface for observers to get state + virtual float getTemperature() const = 0; + virtual float getHumidity() const = 0; + virtual float getPressure() const = 0; +}; + +// Concrete Subject +class WeatherStation : public Subject { +private: + float temperature; + float humidity; + float pressure; + +public: + WeatherStation() : temperature(0.0f), humidity(0.0f), pressure(0.0f) {} + + void setMeasurements(float temp, float humidity, float pressure) { + std::cout << "Setting measurements: " << temp << "°C, " + << humidity << "%, " << pressure << " hPa\n"; + this->temperature = temp; + this->humidity = humidity; + this->pressure = pressure; + measurementsChanged(); + } + + void measurementsChanged() { + notify(); + } + + float getTemperature() const override { + return temperature; + } + + float getHumidity() const override { + return humidity; + } + + float getPressure() const override { + return pressure; + } +}; + +// Concrete Observer +class CurrentConditionsDisplay : public Observer { +private: + float temperature; + float humidity; + Subject* weatherStation; + +public: + CurrentConditionsDisplay(Subject* weatherStation) + : temperature(0.0f), humidity(0.0f), weatherStation(weatherStation) { + // Register with the subject + weatherStation->attach(this); + } + + ~CurrentConditionsDisplay() override { + weatherStation->detach(this); + } + + void update(Subject* subject) override { + if (subject == weatherStation) { + temperature = subject->getTemperature(); + humidity = subject->getHumidity(); + display(); + } + } + + void display() const { + std::cout << "Current conditions: " << temperature << "°C and " + << humidity << "% humidity\n"; + } +}; + +// Concrete Observer +class StatisticsDisplay : public Observer { +private: + float maxTemp; + float minTemp; + float tempSum; + int numReadings; + Subject* weatherStation; + +public: + StatisticsDisplay(Subject* weatherStation) + : maxTemp(0.0f), minTemp(200.0f), tempSum(0.0f), numReadings(0), weatherStation(weatherStation) { + // Register with the subject + weatherStation->attach(this); + } + + ~StatisticsDisplay() override { + weatherStation->detach(this); + } + + void update(Subject* subject) override { + if (subject == weatherStation) { + float temp = subject->getTemperature(); + tempSum += temp; + numReadings++; + + if (temp > maxTemp) { + maxTemp = temp; + } + + if (temp < minTemp) { + minTemp = temp; + } + + display(); + } + } + + void display() const { + std::cout << "Avg/Max/Min temperature: " << (tempSum / numReadings) + << "/" << maxTemp << "/" << minTemp << "\n"; + } +}; + +// Concrete Observer +class ForecastDisplay : public Observer { +private: + float currentPressure; + float lastPressure; + Subject* weatherStation; + +public: + ForecastDisplay(Subject* weatherStation) + : currentPressure(29.92f), lastPressure(0.0f), weatherStation(weatherStation) { + // Register with the subject + weatherStation->attach(this); + } + + ~ForecastDisplay() override { + weatherStation->detach(this); + } + + void update(Subject* subject) override { + if (subject == weatherStation) { + lastPressure = currentPressure; + currentPressure = subject->getPressure(); + display(); + } + } + + void display() const { + std::cout << "Forecast: "; + if (currentPressure > lastPressure) { + std::cout << "Improving weather on the way!\n"; + } else if (currentPressure == lastPressure) { + std::cout << "More of the same\n"; + } else if (currentPressure < lastPressure) { + std::cout << "Watch out for cooler, rainy weather\n"; + } + } +}; + +// Alternative implementation using modern C++ with smart pointers and templates +namespace ModernCpp { + +// Generic Subject class with templated notification +template +class Subject { +private: + // Using std::function for more flexibility in callback signatures + using Callback = std::function; + std::vector> observers; + size_t nextId = 0; + +public: + virtual ~Subject() = default; + + // Returns a token that can be used to detach + size_t attach(Callback callback) { + size_t id = nextId++; + observers.push_back({id, std::move(callback)}); + std::cout << "Modern C++: Attaching observer with ID " << id << "\n"; + return id; + } + + void detach(size_t id) { + std::cout << "Modern C++: Detaching observer with ID " << id << "\n"; + observers.erase( + std::remove_if(observers.begin(), observers.end(), + [id](const auto& pair) { return pair.first == id; }), + observers.end()); + } + + void notify(Args... args) { + std::cout << "Modern C++: Notifying observers...\n"; + for (const auto& [_, callback] : observers) { + callback(args...); + } + } +}; + +// Weather data structure +struct WeatherData { + float temperature; + float humidity; + float pressure; +}; + +// Concrete Subject: WeatherStation +class WeatherStation : public Subject { +private: + WeatherData data; + +public: + WeatherStation() : data{0.0f, 0.0f, 0.0f} {} + + void setMeasurements(float temp, float humidity, float pressure) { + std::cout << "Modern C++: Setting measurements: " << temp << "°C, " + << humidity << "%, " << pressure << " hPa\n"; + data.temperature = temp; + data.humidity = humidity; + data.pressure = pressure; + notify(data); + } + + const WeatherData& getCurrentData() const { + return data; + } +}; + +} // namespace ModernCpp + +int main() { + std::cout << "Observer Pattern Demonstration in C++\n"; + std::cout << "====================================\n\n"; + + // Classic implementation + std::cout << "Classic Implementation:\n"; + std::cout << "----------------------\n"; + + WeatherStation weatherStation; + + // Create displays (observers) + CurrentConditionsDisplay currentDisplay(&weatherStation); + StatisticsDisplay statisticsDisplay(&weatherStation); + ForecastDisplay forecastDisplay(&weatherStation); + + // Simulate weather changes + std::cout << "\nFirst weather update:\n"; + weatherStation.setMeasurements(27.5f, 65.0f, 30.4f); + + std::cout << "\nSecond weather update:\n"; + weatherStation.setMeasurements(28.2f, 70.0f, 29.2f); + + // Modern C++ implementation + std::cout << "\nModern C++ Implementation:\n"; + std::cout << "-------------------------\n"; + + ModernCpp::WeatherStation modernStation; + + // Attach observers using lambdas + auto currentDisplayId = modernStation.attach([](const ModernCpp::WeatherData& data) { + std::cout << "Current conditions: " << data.temperature << "°C and " + << data.humidity << "% humidity\n"; + }); + + // Statistics display with state in the lambda capture + float maxTemp = 0.0f; + float minTemp = 200.0f; + float tempSum = 0.0f; + int numReadings = 0; + + auto statisticsDisplayId = modernStation.attach([&](const ModernCpp::WeatherData& data) { + tempSum += data.temperature; + numReadings++; + + if (data.temperature > maxTemp) { + maxTemp = data.temperature; + } + + if (data.temperature < minTemp) { + minTemp = data.temperature; + } + + std::cout << "Avg/Max/Min temperature: " << (tempSum / numReadings) + << "/" << maxTemp << "/" << minTemp << "\n"; + }); + + // Forecast display with state in the lambda capture + float currentPressure = 29.92f; + float lastPressure = 0.0f; + + auto forecastDisplayId = modernStation.attach([&](const ModernCpp::WeatherData& data) { + lastPressure = currentPressure; + currentPressure = data.pressure; + + std::cout << "Forecast: "; + if (currentPressure > lastPressure) { + std::cout << "Improving weather on the way!\n"; + } else if (currentPressure == lastPressure) { + std::cout << "More of the same\n"; + } else if (currentPressure < lastPressure) { + std::cout << "Watch out for cooler, rainy weather\n"; + } + }); + + // Simulate weather changes + std::cout << "\nFirst weather update:\n"; + modernStation.setMeasurements(27.5f, 65.0f, 30.4f); + + std::cout << "\nSecond weather update:\n"; + modernStation.setMeasurements(28.2f, 70.0f, 29.2f); + + // Detach an observer + std::cout << "\nDetaching the current conditions display...\n"; + modernStation.detach(currentDisplayId); + + std::cout << "\nThird weather update (with one less observer):\n"; + modernStation.setMeasurements(26.7f, 90.0f, 29.2f); + + return 0; +} \ No newline at end of file diff --git a/snippets/design-patterns/observer/ObserverPattern.cs b/snippets/design-patterns/observer/ObserverPattern.cs new file mode 100644 index 0000000..957c369 --- /dev/null +++ b/snippets/design-patterns/observer/ObserverPattern.cs @@ -0,0 +1,448 @@ +/** + * Observer Pattern Implementation in C# + * + * The Observer Pattern is a behavioral design pattern that defines a one-to-many dependency + * between objects so that when one object changes state, all its dependents are notified + * and updated automatically. + * + * This example demonstrates a simple weather station (subject) that notifies + * multiple display devices (observers) when weather data changes. + */ + +using System; +using System.Collections.Generic; + +namespace DesignPatterns.Observer +{ + // ========== Observer Interface ========== + + /// + /// Observer interface to be implemented by all display devices + /// + public interface IObserver + { + /// + /// Update method called by the subject when state changes + /// + /// The current temperature + /// The current humidity + /// The current pressure + void Update(float temperature, float humidity, float pressure); + + /// + /// Gets the name of the observer for identification + /// + string Name { get; } + } + + // ========== Subject Interface ========== + + /// + /// Subject interface to be implemented by objects that notify observers + /// + public interface ISubject + { + /// + /// Register an observer to be notified of changes + /// + /// The observer to register + void RegisterObserver(IObserver observer); + + /// + /// Remove an observer from the notification list + /// + /// The observer to remove + void RemoveObserver(IObserver observer); + + /// + /// Notify all registered observers of state changes + /// + void NotifyObservers(); + } + + // ========== Weather Data Implementation ========== + + /// + /// WeatherData class implements the ISubject interface + /// Maintains the current weather state and notifies observers when it changes + /// + public class WeatherData : ISubject + { + private readonly List _observers; + private float _temperature; + private float _humidity; + private float _pressure; + + /// + /// Constructor initializes the observers list + /// + public WeatherData() + { + _observers = new List(); + } + + /// + /// Register an observer to be notified of changes + /// + /// The observer to register + public void RegisterObserver(IObserver observer) + { + _observers.Add(observer); + Console.WriteLine($"Observer '{observer.Name}' registered"); + } + + /// + /// Remove an observer from the notification list + /// + /// The observer to remove + public void RemoveObserver(IObserver observer) + { + if (_observers.Remove(observer)) + { + Console.WriteLine($"Observer '{observer.Name}' removed"); + } + } + + /// + /// Notify all registered observers of state changes + /// + public void NotifyObservers() + { + foreach (var observer in _observers) + { + observer.Update(_temperature, _humidity, _pressure); + } + } + + /// + /// Called when measurements have been updated + /// + private void MeasurementsChanged() + { + NotifyObservers(); + } + + /// + /// Set new weather measurements + /// + /// New temperature value + /// New humidity value + /// New pressure value + public void SetMeasurements(float temperature, float humidity, float pressure) + { + _temperature = temperature; + _humidity = humidity; + _pressure = pressure; + MeasurementsChanged(); + } + + /// + /// Get the current temperature + /// + public float Temperature => _temperature; + + /// + /// Get the current humidity + /// + public float Humidity => _humidity; + + /// + /// Get the current pressure + /// + public float Pressure => _pressure; + } + + // ========== Display Implementations ========== + + /// + /// CurrentConditionsDisplay implements the IObserver interface + /// Displays the current weather conditions + /// + public class CurrentConditionsDisplay : IObserver + { + private readonly ISubject _weatherData; + private float _temperature; + private float _humidity; + + /// + /// Constructor + /// + /// The weather data subject + /// The name of this observer + public CurrentConditionsDisplay(ISubject weatherData, string name) + { + Name = name; + _weatherData = weatherData; + weatherData.RegisterObserver(this); + } + + /// + /// Update method implementation + /// + /// The current temperature + /// The current humidity + /// The current pressure + public void Update(float temperature, float humidity, float pressure) + { + _temperature = temperature; + _humidity = humidity; + Display(); + } + + /// + /// Display the current conditions + /// + public void Display() + { + Console.WriteLine($"[{Name}] Current conditions: {_temperature:F1}°F and {_humidity:F1}% humidity"); + } + + /// + /// Gets the name of the observer + /// + public string Name { get; } + } + + /// + /// StatisticsDisplay implements the IObserver interface + /// Displays average, minimum, and maximum temperatures + /// + public class StatisticsDisplay : IObserver + { + private readonly ISubject _weatherData; + private float _maxTemp = 0.0f; + private float _minTemp = 200.0f; + private float _tempSum = 0.0f; + private int _numReadings = 0; + + /// + /// Constructor + /// + /// The weather data subject + /// The name of this observer + public StatisticsDisplay(ISubject weatherData, string name) + { + Name = name; + _weatherData = weatherData; + weatherData.RegisterObserver(this); + } + + /// + /// Update method implementation + /// + /// The current temperature + /// The current humidity + /// The current pressure + public void Update(float temperature, float humidity, float pressure) + { + _tempSum += temperature; + _numReadings++; + + if (temperature > _maxTemp) + { + _maxTemp = temperature; + } + + if (temperature < _minTemp) + { + _minTemp = temperature; + } + + Display(); + } + + /// + /// Display the statistics + /// + public void Display() + { + Console.WriteLine($"[{Name}] Avg/Max/Min temperature: {_tempSum / _numReadings:F1}/{_maxTemp:F1}/{_minTemp:F1}"); + } + + /// + /// Gets the name of the observer + /// + public string Name { get; } + } + + /// + /// ForecastDisplay implements the IObserver interface + /// Displays a simple weather forecast based on pressure changes + /// + public class ForecastDisplay : IObserver + { + private readonly ISubject _weatherData; + private float _currentPressure = 29.92f; + private float _lastPressure; + + /// + /// Constructor + /// + /// The weather data subject + /// The name of this observer + public ForecastDisplay(ISubject weatherData, string name) + { + Name = name; + _weatherData = weatherData; + weatherData.RegisterObserver(this); + } + + /// + /// Update method implementation + /// + /// The current temperature + /// The current humidity + /// The current pressure + public void Update(float temperature, float humidity, float pressure) + { + _lastPressure = _currentPressure; + _currentPressure = pressure; + Display(); + } + + /// + /// Display the forecast + /// + public void Display() + { + Console.Write($"[{Name}] Forecast: "); + + if (_currentPressure > _lastPressure) + { + Console.WriteLine("Improving weather on the way!"); + } + else if (Math.Abs(_currentPressure - _lastPressure) < 0.001) + { + Console.WriteLine("More of the same"); + } + else + { + Console.WriteLine("Watch out for cooler, rainy weather"); + } + } + + /// + /// Gets the name of the observer + /// + public string Name { get; } + } + + /// + /// HeatIndexDisplay implements the IObserver interface + /// Displays the heat index based on temperature and humidity + /// + public class HeatIndexDisplay : IObserver + { + private readonly ISubject _weatherData; + private float _heatIndex = 0.0f; + + /// + /// Constructor + /// + /// The weather data subject + /// The name of this observer + public HeatIndexDisplay(ISubject weatherData, string name) + { + Name = name; + _weatherData = weatherData; + weatherData.RegisterObserver(this); + } + + /// + /// Update method implementation + /// + /// The current temperature + /// The current humidity + /// The current pressure + public void Update(float temperature, float humidity, float pressure) + { + _heatIndex = ComputeHeatIndex(temperature, humidity); + Display(); + } + + /// + /// Compute the heat index based on temperature and humidity + /// + /// Temperature + /// Relative humidity + /// Heat index + private float ComputeHeatIndex(float t, float rh) + { + // This is a simplified formula for heat index + return (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh) + + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh)) + + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) + + (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + + (0.0000291583 * (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) + + (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) + + 0.000000000843296 * (t * t * rh * rh * rh)) - + (0.0000000000481975 * (t * t * t * rh * rh * rh)); + } + + /// + /// Display the heat index + /// + public void Display() + { + Console.WriteLine($"[{Name}] Heat index: {_heatIndex:F1}"); + } + + /// + /// Gets the name of the observer + /// + public string Name { get; } + } + + // ========== Demo Code ========== + + /// + /// Demo class to run the weather station example + /// + public class WeatherStationDemo + { + /// + /// Run the weather station demo + /// + public static void RunWeatherStation() + { + // Create the WeatherData subject + var weatherData = new WeatherData(); + + // Create display devices (observers) + var currentDisplay = new CurrentConditionsDisplay(weatherData, "Current Display"); + var statisticsDisplay = new StatisticsDisplay(weatherData, "Statistics Display"); + var forecastDisplay = new ForecastDisplay(weatherData, "Forecast Display"); + var heatIndexDisplay = new HeatIndexDisplay(weatherData, "Heat Index Display"); + + Console.WriteLine("\n=== First Weather Update ==="); + // Simulate new weather measurements + weatherData.SetMeasurements(80, 65, 30.4f); + + Console.WriteLine("\n=== Second Weather Update ==="); + // Simulate new weather measurements + weatherData.SetMeasurements(82, 70, 29.2f); + + Console.WriteLine("\n=== Third Weather Update ==="); + // Simulate new weather measurements + weatherData.SetMeasurements(78, 90, 29.2f); + + Console.WriteLine("\n=== Removing an Observer ==="); + // Remove an observer + weatherData.RemoveObserver(forecastDisplay); + + Console.WriteLine("\n=== Fourth Weather Update ==="); + // One more measurement after removing an observer + weatherData.SetMeasurements(75, 60, 30.1f); + } + } + + // Main program, run the example + class Program + { + static void Main(string[] args) + { + WeatherStationDemo.RunWeatherStation(); + Console.ReadLine(); + } + } +} \ No newline at end of file diff --git a/snippets/design-patterns/observer/ObserverPattern.java b/snippets/design-patterns/observer/ObserverPattern.java new file mode 100644 index 0000000..cfa3194 --- /dev/null +++ b/snippets/design-patterns/observer/ObserverPattern.java @@ -0,0 +1,192 @@ +/** + * Observer Pattern Implementation in Java + * + * This demonstrates a weather station example of the Observer pattern. + */ + +import java.util.ArrayList; +import java.util.List; + +// Observer interface +interface Observer { + void update(); +} + +// Subject interface +interface Subject { + void registerObserver(Observer observer); + void removeObserver(Observer observer); + void notifyObservers(); +} + +// Concrete Subject: WeatherStation +class WeatherStation implements Subject { + private List observers; + private float temperature; + private float humidity; + private float pressure; + + public WeatherStation() { + observers = new ArrayList<>(); + } + + @Override + public void registerObserver(Observer observer) { + observers.add(observer); + } + + @Override + public void removeObserver(Observer observer) { + int index = observers.indexOf(observer); + if (index >= 0) { + observers.remove(index); + } + } + + @Override + public void notifyObservers() { + for (Observer observer : observers) { + observer.update(); + } + } + + public void measurementsChanged() { + notifyObservers(); + } + + public void setMeasurements(float temperature, float humidity, float pressure) { + this.temperature = temperature; + this.humidity = humidity; + this.pressure = pressure; + measurementsChanged(); + } + + // Getter methods that Observers can use to pull data + public float getTemperature() { + return temperature; + } + + public float getHumidity() { + return humidity; + } + + public float getPressure() { + return pressure; + } +} + +// Concrete Observer: CurrentConditionsDisplay +class CurrentConditionsDisplay implements Observer { + private float temperature; + private float humidity; + private WeatherStation weatherStation; + + public CurrentConditionsDisplay(WeatherStation weatherStation) { + this.weatherStation = weatherStation; + weatherStation.registerObserver(this); + } + + @Override + public void update() { + // Pull model - observer gets the data it needs from the subject + this.temperature = weatherStation.getTemperature(); + this.humidity = weatherStation.getHumidity(); + display(); + } + + public void display() { + System.out.println("Current conditions: " + temperature + "°C and " + humidity + "% humidity"); + } +} + +// Concrete Observer: StatisticsDisplay +class StatisticsDisplay implements Observer { + private float maxTemp = 0.0f; + private float minTemp = 200.0f; + private float tempSum = 0.0f; + private int numReadings = 0; + private WeatherStation weatherStation; + + public StatisticsDisplay(WeatherStation weatherStation) { + this.weatherStation = weatherStation; + weatherStation.registerObserver(this); + } + + @Override + public void update() { + float temperature = weatherStation.getTemperature(); + tempSum += temperature; + numReadings++; + + if (temperature > maxTemp) { + maxTemp = temperature; + } + + if (temperature < minTemp) { + minTemp = temperature; + } + + display(); + } + + public void display() { + System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings) + "/" + maxTemp + "/" + minTemp); + } +} + +// Concrete Observer: ForecastDisplay +class ForecastDisplay implements Observer { + private float currentPressure = 29.92f; + private float lastPressure; + private WeatherStation weatherStation; + + public ForecastDisplay(WeatherStation weatherStation) { + this.weatherStation = weatherStation; + weatherStation.registerObserver(this); + } + + @Override + public void update() { + lastPressure = currentPressure; + currentPressure = weatherStation.getPressure(); + + display(); + } + + public void display() { + System.out.print("Forecast: "); + if (currentPressure > lastPressure) { + System.out.println("Improving weather on the way!"); + } else if (currentPressure == lastPressure) { + System.out.println("More of the same"); + } else if (currentPressure < lastPressure) { + System.out.println("Watch out for cooler, rainy weather"); + } + } +} + +// Demonstration +public class ObserverPattern { + public static void main(String[] args) { + // Create the subject + WeatherStation weatherStation = new WeatherStation(); + + // Create and register observers + CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherStation); + StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherStation); + ForecastDisplay forecastDisplay = new ForecastDisplay(weatherStation); + + // Simulate new weather measurements + System.out.println("First weather update:"); + weatherStation.setMeasurements(27.5f, 65.0f, 30.4f); + + System.out.println("\nSecond weather update:"); + weatherStation.setMeasurements(28.2f, 70.0f, 29.2f); + + System.out.println("\nRemoving current conditions display..."); + weatherStation.removeObserver(currentDisplay); + + System.out.println("\nThird weather update (with one less observer):"); + weatherStation.setMeasurements(26.7f, 90.0f, 29.2f); + } +} \ No newline at end of file diff --git a/snippets/design-patterns/observer/observer_pattern.c b/snippets/design-patterns/observer/observer_pattern.c new file mode 100644 index 0000000..8fa5808 --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.c @@ -0,0 +1,528 @@ +/** + * Observer Pattern Implementation in C + * + * The Observer Pattern is a behavioral design pattern that defines a one-to-many dependency + * between objects so that when one object changes state, all its dependents are notified + * and updated automatically. + * + * This example demonstrates a simple weather station (subject) that notifies + * multiple display devices (observers) when weather data changes. + * + * Note: Since C is not an object-oriented language, we use structs with function pointers + * to simulate classes and interfaces. + */ + +#include +#include +#include +#include + +// Forward declarations +typedef struct Observer Observer; +typedef struct Subject Subject; +typedef struct WeatherData WeatherData; +typedef struct DisplayDevice DisplayDevice; + +// ========== Observer Interface ========== + +// Observer "interface" - implemented by display devices +struct Observer { + void (*update)(Observer* self, float temperature, float humidity, float pressure); + char name[50]; +}; + +// ========== Subject Interface ========== + +// Subject "interface" - implemented by weather data +typedef struct ObserverNode { + Observer* observer; + struct ObserverNode* next; +} ObserverNode; + +struct Subject { + void (*registerObserver)(Subject* self, Observer* observer); + void (*removeObserver)(Subject* self, Observer* observer); + void (*notifyObservers)(Subject* self); + + // List of observers + ObserverNode* observers; +}; + +// ========== Weather Data Implementation ========== + +// Concrete Subject implementation +struct WeatherData { + Subject subject; + float temperature; + float humidity; + float pressure; +}; + +// Forward declarations of WeatherData methods +void weatherData_registerObserver(Subject* self, Observer* observer); +void weatherData_removeObserver(Subject* self, Observer* observer); +void weatherData_notifyObservers(Subject* self); +void weatherData_measurementsChanged(WeatherData* self); +void weatherData_setMeasurements(WeatherData* self, float temperature, float humidity, float pressure); + +// Create a new WeatherData instance +WeatherData* createWeatherData() { + WeatherData* weatherData = (WeatherData*)malloc(sizeof(WeatherData)); + if (weatherData == NULL) { + return NULL; + } + + // Initialize the subject interface + weatherData->subject.registerObserver = weatherData_registerObserver; + weatherData->subject.removeObserver = weatherData_removeObserver; + weatherData->subject.notifyObservers = weatherData_notifyObservers; + weatherData->subject.observers = NULL; + + // Initialize weather data + weatherData->temperature = 0.0f; + weatherData->humidity = 0.0f; + weatherData->pressure = 0.0f; + + return weatherData; +} + +// Register an observer +void weatherData_registerObserver(Subject* self, Observer* observer) { + WeatherData* weatherData = (WeatherData*)self; + + // Create a new node + ObserverNode* node = (ObserverNode*)malloc(sizeof(ObserverNode)); + if (node == NULL) { + return; + } + + node->observer = observer; + node->next = NULL; + + // Add to the end of the list + if (self->observers == NULL) { + self->observers = node; + } else { + ObserverNode* current = self->observers; + while (current->next != NULL) { + current = current->next; + } + current->next = node; + } + + printf("Observer '%s' registered\n", observer->name); +} + +// Remove an observer +void weatherData_removeObserver(Subject* self, Observer* observer) { + if (self->observers == NULL) { + return; + } + + // If the first node matches + if (self->observers->observer == observer) { + ObserverNode* temp = self->observers; + self->observers = self->observers->next; + free(temp); + printf("Observer '%s' removed\n", observer->name); + return; + } + + // Check the rest of the list + ObserverNode* current = self->observers; + while (current->next != NULL) { + if (current->next->observer == observer) { + ObserverNode* temp = current->next; + current->next = temp->next; + free(temp); + printf("Observer '%s' removed\n", observer->name); + return; + } + current = current->next; + } +} + +// Notify all observers +void weatherData_notifyObservers(Subject* self) { + WeatherData* weatherData = (WeatherData*)self; + ObserverNode* current = self->observers; + + while (current != NULL) { + current->observer->update(current->observer, weatherData->temperature, + weatherData->humidity, weatherData->pressure); + current = current->next; + } +} + +// Called when measurements change +void weatherData_measurementsChanged(WeatherData* self) { + self->subject.notifyObservers((Subject*)self); +} + +// Set new measurements +void weatherData_setMeasurements(WeatherData* self, float temperature, float humidity, float pressure) { + self->temperature = temperature; + self->humidity = humidity; + self->pressure = pressure; + weatherData_measurementsChanged(self); +} + +// Free WeatherData resources +void destroyWeatherData(WeatherData* weatherData) { + if (weatherData == NULL) { + return; + } + + // Free all observer nodes + ObserverNode* current = weatherData->subject.observers; + while (current != NULL) { + ObserverNode* temp = current; + current = current->next; + free(temp); + } + + // Free the WeatherData itself + free(weatherData); +} + +// ========== Display Device Implementations ========== + +// Current Conditions Display +typedef struct { + Observer observer; + float temperature; + float humidity; + Subject* weatherData; +} CurrentConditionsDisplay; + +// Forward declaration +void currentConditionsDisplay_update(Observer* self, float temperature, float humidity, float pressure); +void currentConditionsDisplay_display(CurrentConditionsDisplay* display); + +// Create a new CurrentConditionsDisplay +CurrentConditionsDisplay* createCurrentConditionsDisplay(Subject* weatherData, const char* name) { + CurrentConditionsDisplay* display = (CurrentConditionsDisplay*)malloc(sizeof(CurrentConditionsDisplay)); + if (display == NULL) { + return NULL; + } + + // Initialize the observer interface + display->observer.update = currentConditionsDisplay_update; + strncpy(display->observer.name, name, sizeof(display->observer.name) - 1); + display->observer.name[sizeof(display->observer.name) - 1] = '\0'; + + // Initialize display data + display->temperature = 0.0f; + display->humidity = 0.0f; + display->weatherData = weatherData; + + // Register with the subject + weatherData->registerObserver(weatherData, (Observer*)display); + + return display; +} + +// Update method implementation +void currentConditionsDisplay_update(Observer* self, float temperature, float humidity, float pressure) { + CurrentConditionsDisplay* display = (CurrentConditionsDisplay*)self; + display->temperature = temperature; + display->humidity = humidity; + currentConditionsDisplay_display(display); +} + +// Display current conditions +void currentConditionsDisplay_display(CurrentConditionsDisplay* display) { + printf("[%s] Current conditions: %.1f°F and %.1f%% humidity\n", + display->observer.name, display->temperature, display->humidity); +} + +// Free CurrentConditionsDisplay resources +void destroyCurrentConditionsDisplay(CurrentConditionsDisplay* display, Subject* weatherData) { + if (display == NULL) { + return; + } + + // Unregister from the subject + if (weatherData != NULL) { + weatherData->removeObserver(weatherData, (Observer*)display); + } + + // Free the display itself + free(display); +} + +// Statistics Display +typedef struct { + Observer observer; + float maxTemp; + float minTemp; + float tempSum; + int numReadings; + Subject* weatherData; +} StatisticsDisplay; + +// Forward declaration +void statisticsDisplay_update(Observer* self, float temperature, float humidity, float pressure); +void statisticsDisplay_display(StatisticsDisplay* display); + +// Create a new StatisticsDisplay +StatisticsDisplay* createStatisticsDisplay(Subject* weatherData, const char* name) { + StatisticsDisplay* display = (StatisticsDisplay*)malloc(sizeof(StatisticsDisplay)); + if (display == NULL) { + return NULL; + } + + // Initialize the observer interface + display->observer.update = statisticsDisplay_update; + strncpy(display->observer.name, name, sizeof(display->observer.name) - 1); + display->observer.name[sizeof(display->observer.name) - 1] = '\0'; + + // Initialize display data + display->maxTemp = 0.0f; + display->minTemp = 200.0f; // A very low starting value + display->tempSum = 0.0f; + display->numReadings = 0; + display->weatherData = weatherData; + + // Register with the subject + weatherData->registerObserver(weatherData, (Observer*)display); + + return display; +} + +// Update method implementation +void statisticsDisplay_update(Observer* self, float temperature, float humidity, float pressure) { + StatisticsDisplay* display = (StatisticsDisplay*)self; + + display->tempSum += temperature; + display->numReadings++; + + if (temperature > display->maxTemp) { + display->maxTemp = temperature; + } + + if (temperature < display->minTemp) { + display->minTemp = temperature; + } + + statisticsDisplay_display(display); +} + +// Display statistics +void statisticsDisplay_display(StatisticsDisplay* display) { + printf("[%s] Avg/Max/Min temperature: %.1f/%.1f/%.1f\n", + display->observer.name, + display->tempSum / display->numReadings, + display->maxTemp, + display->minTemp); +} + +// Free StatisticsDisplay resources +void destroyStatisticsDisplay(StatisticsDisplay* display, Subject* weatherData) { + if (display == NULL) { + return; + } + + // Unregister from the subject + if (weatherData != NULL) { + weatherData->removeObserver(weatherData, (Observer*)display); + } + + // Free the display itself + free(display); +} + +// Forecast Display +typedef struct { + Observer observer; + float currentPressure; + float lastPressure; + Subject* weatherData; +} ForecastDisplay; + +// Forward declaration +void forecastDisplay_update(Observer* self, float temperature, float humidity, float pressure); +void forecastDisplay_display(ForecastDisplay* display); + +// Create a new ForecastDisplay +ForecastDisplay* createForecastDisplay(Subject* weatherData, const char* name) { + ForecastDisplay* display = (ForecastDisplay*)malloc(sizeof(ForecastDisplay)); + if (display == NULL) { + return NULL; + } + + // Initialize the observer interface + display->observer.update = forecastDisplay_update; + strncpy(display->observer.name, name, sizeof(display->observer.name) - 1); + display->observer.name[sizeof(display->observer.name) - 1] = '\0'; + + // Initialize display data + display->currentPressure = 29.92f; // Default starting pressure + display->lastPressure = 0.0f; + display->weatherData = weatherData; + + // Register with the subject + weatherData->registerObserver(weatherData, (Observer*)display); + + return display; +} + +// Update method implementation +void forecastDisplay_update(Observer* self, float temperature, float humidity, float pressure) { + ForecastDisplay* display = (ForecastDisplay*)self; + + display->lastPressure = display->currentPressure; + display->currentPressure = pressure; + + forecastDisplay_display(display); +} + +// Display forecast +void forecastDisplay_display(ForecastDisplay* display) { + printf("[%s] Forecast: ", display->observer.name); + + if (display->currentPressure > display->lastPressure) { + printf("Improving weather on the way!\n"); + } else if (display->currentPressure == display->lastPressure) { + printf("More of the same\n"); + } else if (display->currentPressure < display->lastPressure) { + printf("Watch out for cooler, rainy weather\n"); + } +} + +// Free ForecastDisplay resources +void destroyForecastDisplay(ForecastDisplay* display, Subject* weatherData) { + if (display == NULL) { + return; + } + + // Unregister from the subject + if (weatherData != NULL) { + weatherData->removeObserver(weatherData, (Observer*)display); + } + + // Free the display itself + free(display); +} + +// ========== Heat Index Display ========== + +typedef struct { + Observer observer; + float heatIndex; + Subject* weatherData; +} HeatIndexDisplay; + +// Forward declaration +void heatIndexDisplay_update(Observer* self, float temperature, float humidity, float pressure); +void heatIndexDisplay_display(HeatIndexDisplay* display); +float computeHeatIndex(float temperature, float humidity); + +// Create a new HeatIndexDisplay +HeatIndexDisplay* createHeatIndexDisplay(Subject* weatherData, const char* name) { + HeatIndexDisplay* display = (HeatIndexDisplay*)malloc(sizeof(HeatIndexDisplay)); + if (display == NULL) { + return NULL; + } + + // Initialize the observer interface + display->observer.update = heatIndexDisplay_update; + strncpy(display->observer.name, name, sizeof(display->observer.name) - 1); + display->observer.name[sizeof(display->observer.name) - 1] = '\0'; + + // Initialize display data + display->heatIndex = 0.0f; + display->weatherData = weatherData; + + // Register with the subject + weatherData->registerObserver(weatherData, (Observer*)display); + + return display; +} + +// Update method implementation +void heatIndexDisplay_update(Observer* self, float temperature, float humidity, float pressure) { + HeatIndexDisplay* display = (HeatIndexDisplay*)self; + + display->heatIndex = computeHeatIndex(temperature, humidity); + heatIndexDisplay_display(display); +} + +// Display heat index +void heatIndexDisplay_display(HeatIndexDisplay* display) { + printf("[%s] Heat index: %.1f\n", display->observer.name, display->heatIndex); +} + +// Compute the heat index +float computeHeatIndex(float t, float rh) { + // This is a simplified formula for heat index + return (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh) + + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh)) + + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) + + (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + + (0.0000291583 * (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) + + (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) + + 0.000000000843296 * (t * t * rh * rh * rh)) - + (0.0000000000481975 * (t * t * t * rh * rh * rh))); +} + +// Free HeatIndexDisplay resources +void destroyHeatIndexDisplay(HeatIndexDisplay* display, Subject* weatherData) { + if (display == NULL) { + return; + } + + // Unregister from the subject + if (weatherData != NULL) { + weatherData->removeObserver(weatherData, (Observer*)display); + } + + // Free the display itself + free(display); +} + +// ========== Demo Code ========== + +void runWeatherStation() { + // Create the WeatherData subject + WeatherData* weatherData = createWeatherData(); + + // Create display devices (observers) + CurrentConditionsDisplay* currentDisplay = createCurrentConditionsDisplay((Subject*)weatherData, "Current Display"); + StatisticsDisplay* statsDisplay = createStatisticsDisplay((Subject*)weatherData, "Statistics Display"); + ForecastDisplay* forecastDisplay = createForecastDisplay((Subject*)weatherData, "Forecast Display"); + HeatIndexDisplay* heatIndexDisplay = createHeatIndexDisplay((Subject*)weatherData, "Heat Index Display"); + + printf("\n=== First Weather Update ===\n"); + // Simulate new weather measurements + weatherData_setMeasurements(weatherData, 80.0f, 65.0f, 30.4f); + + printf("\n=== Second Weather Update ===\n"); + // Simulate new weather measurements + weatherData_setMeasurements(weatherData, 82.0f, 70.0f, 29.2f); + + printf("\n=== Third Weather Update ===\n"); + // Simulate new weather measurements + weatherData_setMeasurements(weatherData, 78.0f, 90.0f, 29.2f); + + printf("\n=== Removing an Observer ===\n"); + // Remove an observer + weatherData->subject.removeObserver((Subject*)weatherData, (Observer*)forecastDisplay); + + printf("\n=== Fourth Weather Update ===\n"); + // One more measurement after removing an observer + weatherData_setMeasurements(weatherData, 75.0f, 60.0f, 30.1f); + + // Clean up resources + destroyCurrentConditionsDisplay(currentDisplay, (Subject*)weatherData); + destroyStatisticsDisplay(statsDisplay, (Subject*)weatherData); + destroyForecastDisplay(forecastDisplay, NULL); // Already removed + destroyHeatIndexDisplay(heatIndexDisplay, (Subject*)weatherData); + destroyWeatherData(weatherData); +} + +int main() { + // Run the demo + runWeatherStation(); + return 0; +} \ No newline at end of file diff --git a/snippets/design-patterns/observer/observer_pattern.go b/snippets/design-patterns/observer/observer_pattern.go new file mode 100644 index 0000000..7c9748b --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.go @@ -0,0 +1,295 @@ +package main + +import ( + "fmt" + "math" +) + +/** + * Observer Pattern Implementation in Go + * + * This demonstrates a weather station example of the Observer pattern. + */ + +// Observer interface defines the update method +type Observer interface { + Update(subject Subject) + Display() +} + +// Subject interface defines methods for attaching, detaching, and notifying observers +type Subject interface { + RegisterObserver(observer Observer) + RemoveObserver(observer Observer) + NotifyObservers() + GetTemperature() float64 + GetHumidity() float64 + GetPressure() float64 +} + +// WeatherStation is a concrete subject +type WeatherStation struct { + observers []Observer + temperature float64 + humidity float64 + pressure float64 +} + +// NewWeatherStation creates a new WeatherStation +func NewWeatherStation() *WeatherStation { + return &WeatherStation{ + observers: make([]Observer, 0), + temperature: 0, + humidity: 0, + pressure: 0, + } +} + +// RegisterObserver adds an observer to the list +func (ws *WeatherStation) RegisterObserver(observer Observer) { + fmt.Println("Registering an observer") + ws.observers = append(ws.observers, observer) +} + +// RemoveObserver removes an observer from the list +func (ws *WeatherStation) RemoveObserver(observer Observer) { + fmt.Println("Removing an observer") + for i, obs := range ws.observers { + if obs == observer { + // Remove the observer by slicing it out + ws.observers = append(ws.observers[:i], ws.observers[i+1:]...) + break + } + } +} + +// NotifyObservers notifies all registered observers +func (ws *WeatherStation) NotifyObservers() { + fmt.Println("Notifying observers...") + for _, observer := range ws.observers { + observer.Update(ws) + } +} + +// SetMeasurements sets the measurements and notifies observers +func (ws *WeatherStation) SetMeasurements(temperature, humidity, pressure float64) { + fmt.Printf("Setting measurements: %.1f°C, %.1f%%, %.1f hPa\n", temperature, humidity, pressure) + ws.temperature = temperature + ws.humidity = humidity + ws.pressure = pressure + ws.MeasurementsChanged() +} + +// MeasurementsChanged triggers notifications +func (ws *WeatherStation) MeasurementsChanged() { + ws.NotifyObservers() +} + +// Getter methods for observers +func (ws *WeatherStation) GetTemperature() float64 { + return ws.temperature +} + +func (ws *WeatherStation) GetHumidity() float64 { + return ws.humidity +} + +func (ws *WeatherStation) GetPressure() float64 { + return ws.pressure +} + +// CurrentConditionsDisplay is a concrete observer that displays current conditions +type CurrentConditionsDisplay struct { + temperature float64 + humidity float64 + weatherStation Subject +} + +// NewCurrentConditionsDisplay creates a new CurrentConditionsDisplay +func NewCurrentConditionsDisplay(weatherStation Subject) *CurrentConditionsDisplay { + display := &CurrentConditionsDisplay{ + temperature: 0, + humidity: 0, + weatherStation: weatherStation, + } + weatherStation.RegisterObserver(display) + return display +} + +// Update is called when the subject's state changes +func (cd *CurrentConditionsDisplay) Update(subject Subject) { + cd.temperature = subject.GetTemperature() + cd.humidity = subject.GetHumidity() + cd.Display() +} + +// Display shows the current conditions +func (cd *CurrentConditionsDisplay) Display() { + fmt.Printf("Current conditions: %.1f°C and %.1f%% humidity\n", cd.temperature, cd.humidity) +} + +// StatisticsDisplay is a concrete observer that displays statistics +type StatisticsDisplay struct { + maxTemp float64 + minTemp float64 + tempSum float64 + numReadings int + weatherStation Subject +} + +// NewStatisticsDisplay creates a new StatisticsDisplay +func NewStatisticsDisplay(weatherStation Subject) *StatisticsDisplay { + display := &StatisticsDisplay{ + maxTemp: 0, + minTemp: 200, // A high starting value + tempSum: 0, + numReadings: 0, + weatherStation: weatherStation, + } + weatherStation.RegisterObserver(display) + return display +} + +// Update is called when the subject's state changes +func (sd *StatisticsDisplay) Update(subject Subject) { + temp := subject.GetTemperature() + sd.tempSum += temp + sd.numReadings++ + + sd.maxTemp = math.Max(sd.maxTemp, temp) + sd.minTemp = math.Min(sd.minTemp, temp) + + sd.Display() +} + +// Display shows the temperature statistics +func (sd *StatisticsDisplay) Display() { + avgTemp := sd.tempSum / float64(sd.numReadings) + fmt.Printf("Avg/Max/Min temperature: %.1f/%.1f/%.1f\n", avgTemp, sd.maxTemp, sd.minTemp) +} + +// ForecastDisplay is a concrete observer that displays weather forecasts +type ForecastDisplay struct { + currentPressure float64 + lastPressure float64 + weatherStation Subject +} + +// NewForecastDisplay creates a new ForecastDisplay +func NewForecastDisplay(weatherStation Subject) *ForecastDisplay { + display := &ForecastDisplay{ + currentPressure: 29.92, // Starting with a default value + lastPressure: 0, + weatherStation: weatherStation, + } + weatherStation.RegisterObserver(display) + return display +} + +// Update is called when the subject's state changes +func (fd *ForecastDisplay) Update(subject Subject) { + fd.lastPressure = fd.currentPressure + fd.currentPressure = subject.GetPressure() + fd.Display() +} + +// Display shows the weather forecast +func (fd *ForecastDisplay) Display() { + fmt.Print("Forecast: ") + if fd.currentPressure > fd.lastPressure { + fmt.Println("Improving weather on the way!") + } else if fd.currentPressure == fd.lastPressure { + fmt.Println("More of the same") + } else if fd.currentPressure < fd.lastPressure { + fmt.Println("Watch out for cooler, rainy weather") + } +} + +// ChannelObserver shows an alternative implementation using Go channels +type ChannelObserver struct { + ch chan WeatherData +} + +// WeatherData represents the data sent through channels +type WeatherData struct { + Temperature float64 + Humidity float64 + Pressure float64 +} + +// NewChannelObserver creates a new channel-based observer +func NewChannelObserver() *ChannelObserver { + return &ChannelObserver{ + ch: make(chan WeatherData, 10), // Buffered channel to avoid blocking + } +} + +// Start begins listening for weather updates +func (co *ChannelObserver) Start() { + go func() { + for data := range co.ch { + fmt.Printf("\nChannel Observer: Received weather update: %.1f°C, %.1f%%, %.1f hPa\n", + data.Temperature, data.Humidity, data.Pressure) + } + }() +} + +// Stop closes the channel and stops the goroutine +func (co *ChannelObserver) Stop() { + close(co.ch) +} + +// SendUpdate sends weather data to the observer +func (co *ChannelObserver) SendUpdate(data WeatherData) { + select { + case co.ch <- data: + // Data sent successfully + default: + fmt.Println("Channel full, update dropped") + } +} + +func main() { + fmt.Println("Observer Pattern Demonstration in Go") + fmt.Println("===================================") + + // Create the weather station (subject) + weatherStation := NewWeatherStation() + + // Create and register displays (observers) + currentDisplay := NewCurrentConditionsDisplay(weatherStation) + statisticsDisplay := NewStatisticsDisplay(weatherStation) + forecastDisplay := NewForecastDisplay(weatherStation) + + // Simulate weather changes + fmt.Println("\nFirst weather update:") + weatherStation.SetMeasurements(27.5, 65.0, 30.4) + + fmt.Println("\nSecond weather update:") + weatherStation.SetMeasurements(28.2, 70.0, 29.2) + + // Remove an observer + fmt.Println("\nRemoving current conditions display...") + weatherStation.RemoveObserver(currentDisplay) + + fmt.Println("\nThird weather update (with one less observer):") + weatherStation.SetMeasurements(26.7, 90.0, 29.2) + + // Demonstrate channel-based implementation + fmt.Println("\nChannel-based Observer Demo:") + fmt.Println("---------------------------") + channelObserver := NewChannelObserver() + channelObserver.Start() + + fmt.Println("Sending updates via channel...") + channelObserver.SendUpdate(WeatherData{27.5, 65.0, 30.4}) + channelObserver.SendUpdate(WeatherData{28.2, 70.0, 29.2}) + channelObserver.SendUpdate(WeatherData{26.7, 90.0, 29.2}) + + // Allow time for the goroutine to process + fmt.Println("\nPress Enter to exit...") + fmt.Scanln() + + // Clean up + channelObserver.Stop() +} \ No newline at end of file diff --git a/snippets/design-patterns/observer/observer_pattern.js b/snippets/design-patterns/observer/observer_pattern.js new file mode 100644 index 0000000..7401a60 --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.js @@ -0,0 +1,280 @@ +/** + * Observer Pattern Implementation in JavaScript + * + * This demonstrates a Weather Station example of the Observer pattern. + */ + +// Subject interface +class Subject { + constructor() { + this.observers = []; + } + + // Add an observer to the list + attach(observer) { + if (this.observers.includes(observer)) { + console.log('Observer already attached'); + return; + } + console.log('Attaching an observer'); + this.observers.push(observer); + } + + // Remove an observer from the list + detach(observer) { + const observerIndex = this.observers.indexOf(observer); + if (observerIndex === -1) { + console.log('Observer not found'); + return; + } + console.log('Detaching an observer'); + this.observers.splice(observerIndex, 1); + } + + // Notify all observers about an event + notify() { + console.log('Notifying observers...'); + for (const observer of this.observers) { + observer.update(this); + } + } +} + +// Concrete Subject: WeatherStation +class WeatherStation extends Subject { + constructor() { + super(); + this.temperature = 0; + this.humidity = 0; + this.pressure = 0; + } + + // Getters for weather measurements + getTemperature() { + return this.temperature; + } + + getHumidity() { + return this.humidity; + } + + getPressure() { + return this.pressure; + } + + // Update measurements and notify observers + setMeasurements(temperature, humidity, pressure) { + console.log(`Setting measurements: ${temperature}°C, ${humidity}%, ${pressure} hPa`); + this.temperature = temperature; + this.humidity = humidity; + this.pressure = pressure; + this.measurementsChanged(); + } + + measurementsChanged() { + this.notify(); + } +} + +// Observer interface +class Observer { + update(subject) { + // This method should be overridden by concrete observers + throw new Error('Method "update" must be implemented.'); + } +} + +// Concrete Observer: CurrentConditionsDisplay +class CurrentConditionsDisplay extends Observer { + constructor(weatherStation) { + super(); + this.weatherStation = weatherStation; + this.temperature = 0; + this.humidity = 0; + + // Register this observer with the subject + this.weatherStation.attach(this); + } + + update(subject) { + if (subject instanceof WeatherStation) { + this.temperature = subject.getTemperature(); + this.humidity = subject.getHumidity(); + this.display(); + } + } + + display() { + console.log(`Current conditions: ${this.temperature}°C and ${this.humidity}% humidity`); + } +} + +// Concrete Observer: StatisticsDisplay +class StatisticsDisplay extends Observer { + constructor(weatherStation) { + super(); + this.weatherStation = weatherStation; + this.maxTemp = 0; + this.minTemp = 200; + this.tempSum = 0; + this.numReadings = 0; + + // Register this observer with the subject + this.weatherStation.attach(this); + } + + update(subject) { + if (subject instanceof WeatherStation) { + const temp = subject.getTemperature(); + this.tempSum += temp; + this.numReadings++; + + if (temp > this.maxTemp) { + this.maxTemp = temp; + } + + if (temp < this.minTemp) { + this.minTemp = temp; + } + + this.display(); + } + } + + display() { + const avgTemp = this.tempSum / this.numReadings; + console.log(`Avg/Max/Min temperature: ${avgTemp.toFixed(1)}/${this.maxTemp}/${this.minTemp}`); + } +} + +// Concrete Observer: ForecastDisplay +class ForecastDisplay extends Observer { + constructor(weatherStation) { + super(); + this.weatherStation = weatherStation; + this.currentPressure = 29.92; + this.lastPressure = 0; + + // Register this observer with the subject + this.weatherStation.attach(this); + } + + update(subject) { + if (subject instanceof WeatherStation) { + this.lastPressure = this.currentPressure; + this.currentPressure = subject.getPressure(); + this.display(); + } + } + + display() { + let forecast = 'Forecast: '; + + if (this.currentPressure > this.lastPressure) { + forecast += 'Improving weather on the way!'; + } else if (this.currentPressure === this.lastPressure) { + forecast += 'More of the same'; + } else if (this.currentPressure < this.lastPressure) { + forecast += 'Watch out for cooler, rainy weather'; + } + + console.log(forecast); + } +} + +// Example usage +function runWeatherStation() { + console.log("Weather Station Demo"); + console.log("==================="); + + // Create the weather station (subject) + const weatherStation = new WeatherStation(); + + // Create displays (observers) + const currentDisplay = new CurrentConditionsDisplay(weatherStation); + const statisticsDisplay = new StatisticsDisplay(weatherStation); + const forecastDisplay = new ForecastDisplay(weatherStation); + + // Simulate weather changes + console.log("\nFirst weather update:"); + weatherStation.setMeasurements(27.5, 65, 30.4); + + console.log("\nSecond weather update:"); + weatherStation.setMeasurements(28.2, 70, 29.2); + + // Remove an observer + console.log("\nDetaching the current conditions display..."); + weatherStation.detach(currentDisplay); + + console.log("\nThird weather update (with one less observer):"); + weatherStation.setMeasurements(26.7, 90, 29.2); +} + +// Run the demo +runWeatherStation(); + +// Event-based Observer Pattern using Node.js EventEmitter +// This is a more JavaScript-idiomatic way to implement the Observer pattern +function eventBasedObserverDemo() { + const EventEmitter = require('events'); + + // Subject as an EventEmitter + class WeatherStationEmitter extends EventEmitter { + constructor() { + super(); + this.temperature = 0; + this.humidity = 0; + this.pressure = 0; + } + + setMeasurements(temperature, humidity, pressure) { + console.log(`Setting measurements: ${temperature}°C, ${humidity}%, ${pressure} hPa`); + this.temperature = temperature; + this.humidity = humidity; + this.pressure = pressure; + + // Emit an event with the updated data + this.emit('measurementsChanged', { + temperature, + humidity, + pressure + }); + } + } + + console.log("\nEvent-Based Observer Pattern Demo"); + console.log("================================="); + + const weatherStation = new WeatherStationEmitter(); + + // Add observers using event listeners + weatherStation.on('measurementsChanged', (data) => { + console.log(`Current conditions: ${data.temperature}°C and ${data.humidity}% humidity`); + }); + + let tempSum = 0; + let numReadings = 0; + let maxTemp = 0; + let minTemp = 200; + + weatherStation.on('measurementsChanged', (data) => { + tempSum += data.temperature; + numReadings++; + + if (data.temperature > maxTemp) maxTemp = data.temperature; + if (data.temperature < minTemp) minTemp = data.temperature; + + const avgTemp = tempSum / numReadings; + console.log(`Avg/Max/Min temperature: ${avgTemp.toFixed(1)}/${maxTemp}/${minTemp}`); + }); + + // Simulate weather changes + console.log("\nFirst weather update:"); + weatherStation.setMeasurements(27.5, 65, 30.4); + + console.log("\nSecond weather update:"); + weatherStation.setMeasurements(28.2, 70, 29.2); +} + +// Run the event-based demo if running in Node.js environment +eventBasedObserverDemo(); \ No newline at end of file diff --git a/snippets/design-patterns/observer/observer_pattern.php b/snippets/design-patterns/observer/observer_pattern.php new file mode 100644 index 0000000..e416753 --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.php @@ -0,0 +1,474 @@ +observers[] = $observer; + echo "Observer " . get_class($observer) . " registered\n"; + } + + /** + * Remove an observer from the notification list + * + * @param Observer $observer The observer to remove + * @return void + */ + public function removeObserver(Observer $observer): void { + $index = array_search($observer, $this->observers, true); + if ($index !== false) { + unset($this->observers[$index]); + $this->observers = array_values($this->observers); // Re-index array + echo "Observer " . get_class($observer) . " removed\n"; + } + } + + /** + * Notify all registered observers of state changes + * + * @return void + */ + public function notifyObservers(): void { + foreach ($this->observers as $observer) { + $observer->update($this->temperature, $this->humidity, $this->pressure); + } + } + + /** + * Called when measurements have been updated + * + * @return void + */ + public function measurementsChanged(): void { + $this->notifyObservers(); + } + + /** + * Set new weather measurements + * + * @param float $temperature New temperature value + * @param float $humidity New humidity value + * @param float $pressure New pressure value + * @return void + */ + public function setMeasurements(float $temperature, float $humidity, float $pressure): void { + $this->temperature = $temperature; + $this->humidity = $humidity; + $this->pressure = $pressure; + $this->measurementsChanged(); + } + + /** + * Get the current temperature + * + * @return float Current temperature + */ + public function getTemperature(): float { + return $this->temperature; + } + + /** + * Get the current humidity + * + * @return float Current humidity + */ + public function getHumidity(): float { + return $this->humidity; + } + + /** + * Get the current pressure + * + * @return float Current pressure + */ + public function getPressure(): float { + return $this->pressure; + } +} + +// ========== Display Implementations ========== + +/** + * CurrentConditionsDisplay class implements the Observer interface + * Displays the current weather conditions + */ +class CurrentConditionsDisplay implements Observer { + /** + * @var float Current temperature + */ + private $temperature; + + /** + * @var float Current humidity + */ + private $humidity; + + /** + * @var Subject The weather data subject + */ + private $weatherData; + + /** + * Constructor + * + * @param Subject $weatherData The weather data subject + */ + public function __construct(Subject $weatherData) { + $this->weatherData = $weatherData; + $weatherData->registerObserver($this); + } + + /** + * Update method called by the subject when state changes + * + * @param float $temperature The current temperature + * @param float $humidity The current humidity + * @param float $pressure The current pressure + * @return void + */ + public function update(float $temperature, float $humidity, float $pressure): void { + $this->temperature = $temperature; + $this->humidity = $humidity; + $this->display(); + } + + /** + * Display the current conditions + * + * @return void + */ + public function display(): void { + echo "Current conditions: {$this->temperature}°F and {$this->humidity}% humidity\n"; + } +} + +/** + * StatisticsDisplay class implements the Observer interface + * Displays average, minimum, and maximum temperatures + */ +class StatisticsDisplay implements Observer { + /** + * @var float Maximum temperature recorded + */ + private $maxTemp = 0.0; + + /** + * @var float Minimum temperature recorded + */ + private $minTemp = 200.0; + + /** + * @var float Sum of all temperature readings + */ + private $tempSum = 0.0; + + /** + * @var int Number of readings taken + */ + private $numReadings = 0; + + /** + * @var Subject The weather data subject + */ + private $weatherData; + + /** + * Constructor + * + * @param Subject $weatherData The weather data subject + */ + public function __construct(Subject $weatherData) { + $this->weatherData = $weatherData; + $weatherData->registerObserver($this); + } + + /** + * Update method called by the subject when state changes + * + * @param float $temperature The current temperature + * @param float $humidity The current humidity + * @param float $pressure The current pressure + * @return void + */ + public function update(float $temperature, float $humidity, float $pressure): void { + $this->tempSum += $temperature; + $this->numReadings++; + + if ($temperature > $this->maxTemp) { + $this->maxTemp = $temperature; + } + + if ($temperature < $this->minTemp) { + $this->minTemp = $temperature; + } + + $this->display(); + } + + /** + * Display the statistics + * + * @return void + */ + public function display(): void { + $avgTemp = $this->tempSum / $this->numReadings; + echo "Avg/Max/Min temperature: " . round($avgTemp, 1) . "/" . + $this->maxTemp . "/" . $this->minTemp . "\n"; + } +} + +/** + * ForecastDisplay class implements the Observer interface + * Displays a simple weather forecast based on pressure changes + */ +class ForecastDisplay implements Observer { + /** + * @var float Current barometric pressure + */ + private $currentPressure = 29.92; + + /** + * @var float Previous barometric pressure + */ + private $lastPressure; + + /** + * @var Subject The weather data subject + */ + private $weatherData; + + /** + * Constructor + * + * @param Subject $weatherData The weather data subject + */ + public function __construct(Subject $weatherData) { + $this->weatherData = $weatherData; + $weatherData->registerObserver($this); + } + + /** + * Update method called by the subject when state changes + * + * @param float $temperature The current temperature + * @param float $humidity The current humidity + * @param float $pressure The current pressure + * @return void + */ + public function update(float $temperature, float $humidity, float $pressure): void { + $this->lastPressure = $this->currentPressure; + $this->currentPressure = $pressure; + $this->display(); + } + + /** + * Display the forecast + * + * @return void + */ + public function display(): void { + echo "Forecast: "; + if ($this->currentPressure > $this->lastPressure) { + echo "Improving weather on the way!\n"; + } else if ($this->currentPressure == $this->lastPressure) { + echo "More of the same\n"; + } else if ($this->currentPressure < $this->lastPressure) { + echo "Watch out for cooler, rainy weather\n"; + } + } +} + +/** + * HeatIndexDisplay class implements the Observer interface + * Displays the heat index based on temperature and humidity + */ +class HeatIndexDisplay implements Observer { + /** + * @var float Current heat index + */ + private $heatIndex = 0.0; + + /** + * @var Subject The weather data subject + */ + private $weatherData; + + /** + * Constructor + * + * @param Subject $weatherData The weather data subject + */ + public function __construct(Subject $weatherData) { + $this->weatherData = $weatherData; + $weatherData->registerObserver($this); + } + + /** + * Update method called by the subject when state changes + * + * @param float $temperature The current temperature + * @param float $humidity The current humidity + * @param float $pressure The current pressure + * @return void + */ + public function update(float $temperature, float $humidity, float $pressure): void { + $this->heatIndex = $this->computeHeatIndex($temperature, $humidity); + $this->display(); + } + + /** + * Compute the heat index based on temperature and humidity + * + * @param float $t Temperature + * @param float $rh Relative humidity + * @return float Heat index + */ + private function computeHeatIndex(float $t, float $rh): float { + // This is a simplified formula for heat index + return (float)((16.923 + (0.185212 * $t) + (5.37941 * $rh) - (0.100254 * $t * $rh) + + (0.00941695 * ($t * $t)) + (0.00728898 * ($rh * $rh)) + + (0.000345372 * ($t * $t * $rh)) - (0.000814971 * ($t * $rh * $rh)) + + (0.0000102102 * ($t * $t * $rh * $rh)) - (0.000038646 * ($t * $t * $t)) + + (0.0000291583 * ($rh * $rh * $rh)) + (0.00000142721 * ($t * $t * $t * $rh)) + + (0.000000197483 * ($t * $rh * $rh * $rh)) - (0.0000000218429 * ($t * $t * $t * $rh * $rh)) + + 0.000000000843296 * ($t * $t * $rh * $rh * $rh)) - + (0.0000000000481975 * ($t * $t * $t * $rh * $rh * $rh))); + } + + /** + * Display the heat index + * + * @return void + */ + public function display(): void { + echo "Heat index: " . round($this->heatIndex, 1) . "\n"; + } +} + +// ========== Demo Code ========== + +/** + * Run the weather station demo + */ +function runWeatherStation() { + // Create the WeatherData subject + $weatherData = new WeatherData(); + + // Create display devices (observers) + $currentDisplay = new CurrentConditionsDisplay($weatherData); + $statisticsDisplay = new StatisticsDisplay($weatherData); + $forecastDisplay = new ForecastDisplay($weatherData); + $heatIndexDisplay = new HeatIndexDisplay($weatherData); + + echo "\n=== First Weather Update ===\n"; + // Simulate new weather measurements + $weatherData->setMeasurements(80, 65, 30.4); + + echo "\n=== Second Weather Update ===\n"; + // Simulate new weather measurements + $weatherData->setMeasurements(82, 70, 29.2); + + echo "\n=== Third Weather Update ===\n"; + // Simulate new weather measurements + $weatherData->setMeasurements(78, 90, 29.2); + + echo "\n=== Removing an Observer ===\n"; + // Remove an observer + $weatherData->removeObserver($forecastDisplay); + + echo "\n=== Fourth Weather Update ===\n"; + // One more measurement after removing an observer + $weatherData->setMeasurements(75, 60, 30.1); +} + +// Run the demo +runWeatherStation(); diff --git a/snippets/design-patterns/observer/observer_pattern.py b/snippets/design-patterns/observer/observer_pattern.py new file mode 100644 index 0000000..af3e7d4 --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +""" +Observer Pattern Implementation in Python + +This example demonstrates a news publisher system where subscribers +can register to receive updates when new articles are published. +""" + +from abc import ABC, abstractmethod +from typing import List + + +# Observer interface +class Observer(ABC): + """ + The Observer interface declares the update method, used by subjects + to notify observers of changes. + """ + @abstractmethod + def update(self, subject) -> None: + """ + Receive update from subject. + """ + pass + + +# Subject interface +class Subject(ABC): + """ + The Subject interface declares methods for managing observers. + """ + @abstractmethod + def attach(self, observer: Observer) -> None: + """ + Attach an observer to the subject. + """ + pass + + @abstractmethod + def detach(self, observer: Observer) -> None: + """ + Detach an observer from the subject. + """ + pass + + @abstractmethod + def notify(self) -> None: + """ + Notify all observers about an event. + """ + pass + + +# Concrete Subject +class NewsPublisher(Subject): + """ + The NewsPublisher maintains a list of observers and sends notifications + when a new article is published. + """ + def __init__(self): + self._observers: List[Observer] = [] + self._latest_article: dict = {} + self._articles: List[dict] = [] + + def attach(self, observer: Observer) -> None: + print(f"NewsPublisher: Attached an observer.") + self._observers.append(observer) + + def detach(self, observer: Observer) -> None: + print(f"NewsPublisher: Detached an observer.") + self._observers.remove(observer) + + def notify(self) -> None: + """ + Trigger an update in each subscriber. + """ + print("NewsPublisher: Notifying observers...") + for observer in self._observers: + observer.update(self) + + def publish_article(self, title: str, content: str, category: str) -> None: + """ + Publishes a new article and notifies observers. + """ + article = { + "title": title, + "content": content, + "category": category + } + self._latest_article = article + self._articles.append(article) + print(f"NewsPublisher: Published new article - '{title}'") + self.notify() + + @property + def latest_article(self) -> dict: + """ + Returns the latest published article. + """ + return self._latest_article + + @property + def articles(self) -> List[dict]: + """ + Returns all articles. + """ + return self._articles + + +# Concrete Observer +class NewsSubscriber(Observer): + """ + Concrete Observers react to the updates issued by the NewsPublisher + they are attached to. + """ + def __init__(self, name: str, categories: List[str] = None): + self.name = name + self.categories = categories or [] # Categories the subscriber is interested in + + def update(self, subject: Subject) -> None: + """ + Receive update from publisher and print the latest article + if it matches the subscriber's interests. + """ + if not isinstance(subject, NewsPublisher): + return + + latest = subject.latest_article + + # If subscriber has category preferences and the article category matches + if not self.categories or latest.get("category") in self.categories: + print(f"\n{self.name} received news alert:") + print(f"Title: {latest.get('title')}") + print(f"Category: {latest.get('category')}") + print(f"Content snippet: {latest.get('content')[:50]}...") + else: + print(f"\n{self.name} ignored article in category '{latest.get('category')}' (not subscribed)") + + def subscribe_to_category(self, category: str) -> None: + """ + Add a category to subscriber's interests. + """ + if category not in self.categories: + self.categories.append(category) + print(f"{self.name} subscribed to category: {category}") + + def unsubscribe_from_category(self, category: str) -> None: + """ + Remove a category from subscriber's interests. + """ + if category in self.categories: + self.categories.remove(category) + print(f"{self.name} unsubscribed from category: {category}") + + +# Specialized Concrete Observer +class PremiumSubscriber(NewsSubscriber): + """ + A premium subscriber gets more detailed notifications. + """ + def update(self, subject: Subject) -> None: + """ + Premium subscribers receive full content regardless of category. + """ + if not isinstance(subject, NewsPublisher): + return + + latest = subject.latest_article + print(f"\n[PREMIUM] {self.name} received breaking news:") + print(f"Title: {latest.get('title')}") + print(f"Category: {latest.get('category')}") + print(f"Full content: {latest.get('content')}") + + +def main(): + """ + The client code. + """ + # Create publisher + news_publisher = NewsPublisher() + + # Create subscribers + john = NewsSubscriber("John", ["politics", "technology"]) + lisa = NewsSubscriber("Lisa", ["entertainment", "sports"]) + mike = PremiumSubscriber("Mike") # Premium subscriber gets all categories + + # Attach subscribers to publisher + news_publisher.attach(john) + news_publisher.attach(lisa) + news_publisher.attach(mike) + + # Publish articles + print("\n--- First Article ---") + news_publisher.publish_article( + "New AI Breakthrough", + "Researchers have developed a new AI model that can understand complex human emotions.", + "technology" + ) + + print("\n--- Second Article ---") + news_publisher.publish_article( + "Movie Star Announces Retirement", + "Famous actor decides to retire after 30 years in the industry.", + "entertainment" + ) + + # Detach a subscriber + news_publisher.detach(lisa) + + # John subscribes to a new category + john.subscribe_to_category("health") + + print("\n--- Third Article ---") + news_publisher.publish_article( + "New Health Guidelines Released", + "Government announces updated health guidelines for the pandemic.", + "health" + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/snippets/design-patterns/observer/observer_pattern.rb b/snippets/design-patterns/observer/observer_pattern.rb new file mode 100644 index 0000000..c6aa78d --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.rb @@ -0,0 +1,244 @@ +#!/usr/bin/env ruby + +# Observer Pattern Implementation in Ruby +# +# The Observer Pattern is a behavioral design pattern that defines a one-to-many dependency +# between objects so that when one object changes state, all its dependents are notified +# and updated automatically. +# +# This example demonstrates a simple weather station (subject) that notifies +# multiple display devices (observers) when weather data changes. + +# ========== Subject Module ========== + +# Subject module to be included by classes that need to notify observers +module Subject + # Initialize the observers array + def initialize_subject + @observers = [] + end + + # Register an observer to be notified of changes + def register_observer(observer) + @observers << observer + puts "Observer #{observer.class} registered" + end + + # Remove an observer from the notification list + def remove_observer(observer) + if @observers.delete(observer) + puts "Observer #{observer.class} removed" + end + end + + # Notify all registered observers of state changes + def notify_observers + @observers.each do |observer| + observer.update(@temperature, @humidity, @pressure) + end + end +end + +# ========== Observer Module ========== + +# Observer module to be included by classes that need to be notified of changes +module Observer + # Update method to be implemented by concrete observers + def update(temperature, humidity, pressure) + raise NotImplementedError, "#{self.class} must implement update method" + end +end + +# ========== Weather Data Implementation ========== + +# WeatherData class includes the Subject module +class WeatherData + include Subject + + attr_reader :temperature, :humidity, :pressure + + # Initialize the weather data + def initialize + initialize_subject + @temperature = 0.0 + @humidity = 0.0 + @pressure = 0.0 + end + + # Called when measurements have been updated + def measurements_changed + notify_observers + end + + # Set new weather measurements + def set_measurements(temperature, humidity, pressure) + @temperature = temperature + @humidity = humidity + @pressure = pressure + measurements_changed + end +end + +# ========== Display Implementations ========== + +# CurrentConditionsDisplay class includes the Observer module +class CurrentConditionsDisplay + include Observer + + # Initialize with weather data subject + def initialize(weather_data) + @weather_data = weather_data + @temperature = 0.0 + @humidity = 0.0 + weather_data.register_observer(self) + end + + # Update method implementation + def update(temperature, humidity, pressure) + @temperature = temperature + @humidity = humidity + display + end + + # Display the current conditions + def display + puts "Current conditions: #{@temperature}°F and #{@humidity}% humidity" + end +end + +# StatisticsDisplay class includes the Observer module +class StatisticsDisplay + include Observer + + # Initialize with weather data subject + def initialize(weather_data) + @weather_data = weather_data + @max_temp = 0.0 + @min_temp = 200.0 + @temp_sum = 0.0 + @num_readings = 0 + weather_data.register_observer(self) + end + + # Update method implementation + def update(temperature, humidity, pressure) + @temp_sum += temperature + @num_readings += 1 + + @max_temp = temperature if temperature > @max_temp + @min_temp = temperature if temperature < @min_temp + + display + end + + # Display the statistics + def display + avg_temp = @temp_sum / @num_readings + puts "Avg/Max/Min temperature: #{avg_temp.round(1)}/#{@max_temp}/#{@min_temp}" + end +end + +# ForecastDisplay class includes the Observer module +class ForecastDisplay + include Observer + + # Initialize with weather data subject + def initialize(weather_data) + @weather_data = weather_data + @current_pressure = 29.92 + @last_pressure = 0.0 + weather_data.register_observer(self) + end + + # Update method implementation + def update(temperature, humidity, pressure) + @last_pressure = @current_pressure + @current_pressure = pressure + display + end + + # Display the forecast + def display + print "Forecast: " + if @current_pressure > @last_pressure + puts "Improving weather on the way!" + elsif @current_pressure == @last_pressure + puts "More of the same" + elsif @current_pressure < @last_pressure + puts "Watch out for cooler, rainy weather" + end + end +end + +# HeatIndexDisplay class includes the Observer module +class HeatIndexDisplay + include Observer + + # Initialize with weather data subject + def initialize(weather_data) + @weather_data = weather_data + @heat_index = 0.0 + weather_data.register_observer(self) + end + + # Update method implementation + def update(temperature, humidity, pressure) + @heat_index = compute_heat_index(temperature, humidity) + display + end + + # Compute the heat index based on temperature and humidity + def compute_heat_index(t, rh) + # This is a simplified formula for heat index + (16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh) + + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh)) + + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) + + (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + + (0.0000291583 * (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) + + (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) + + 0.000000000843296 * (t * t * rh * rh * rh)) - + (0.0000000000481975 * (t * t * t * rh * rh * rh)) + end + + # Display the heat index + def display + puts "Heat index: #{@heat_index.round(1)}" + end +end + +# ========== Demo Code ========== + +# Run the weather station demo +def run_weather_station + # Create the WeatherData subject + weather_data = WeatherData.new + + # Create display devices (observers) + current_display = CurrentConditionsDisplay.new(weather_data) + statistics_display = StatisticsDisplay.new(weather_data) + forecast_display = ForecastDisplay.new(weather_data) + heat_index_display = HeatIndexDisplay.new(weather_data) + + puts "\n=== First Weather Update ===" + # Simulate new weather measurements + weather_data.set_measurements(80, 65, 30.4) + + puts "\n=== Second Weather Update ===" + # Simulate new weather measurements + weather_data.set_measurements(82, 70, 29.2) + + puts "\n=== Third Weather Update ===" + # Simulate new weather measurements + weather_data.set_measurements(78, 90, 29.2) + + puts "\n=== Removing an Observer ===" + # Remove an observer + weather_data.remove_observer(forecast_display) + + puts "\n=== Fourth Weather Update ===" + # One more measurement after removing an observer + weather_data.set_measurements(75, 60, 30.1) +end + +# Run the demo +run_weather_station diff --git a/snippets/design-patterns/observer/observer_pattern.rs b/snippets/design-patterns/observer/observer_pattern.rs new file mode 100644 index 0000000..8870d12 --- /dev/null +++ b/snippets/design-patterns/observer/observer_pattern.rs @@ -0,0 +1,338 @@ +/** + * Observer Pattern Implementation in Rust + * + * The Observer Pattern is a behavioral design pattern that defines a one-to-many dependency + * between objects so that when one object changes state, all its dependents are notified + * and updated automatically. + * + * This example demonstrates a simple weather station (subject) that notifies + * multiple display devices (observers) when weather data changes. + */ + +use std::cell::RefCell; +use std::rc::{Rc, Weak}; +use std::fmt; + +// ========== Observer Trait ========== + +/// Observer trait to be implemented by all display devices +trait Observer { + /// Update method called by the subject when state changes + fn update(&mut self, temperature: f32, humidity: f32, pressure: f32); + + /// Get the name of the observer for identification + fn name(&self) -> &str; +} + +// ========== Subject Trait ========== + +/// Subject trait to be implemented by objects that notify observers +trait Subject { + /// Register an observer to be notified of changes + fn register_observer(&mut self, observer: Rc>); + + /// Remove an observer from the notification list + fn remove_observer(&mut self, observer: &Rc>); + + /// Notify all registered observers of state changes + fn notify_observers(&self); +} + +// ========== Weather Data Implementation ========== + +/// WeatherData struct implements the Subject trait +struct WeatherData { + observers: Vec>>, + temperature: f32, + humidity: f32, + pressure: f32, +} + +impl WeatherData { + /// Create a new WeatherData instance + fn new() -> Self { + WeatherData { + observers: Vec::new(), + temperature: 0.0, + humidity: 0.0, + pressure: 0.0, + } + } + + /// Called when measurements have been updated + fn measurements_changed(&self) { + self.notify_observers(); + } + + /// Set new weather measurements + fn set_measurements(&mut self, temperature: f32, humidity: f32, pressure: f32) { + self.temperature = temperature; + self.humidity = humidity; + self.pressure = pressure; + self.measurements_changed(); + } +} + +impl Subject for WeatherData { + fn register_observer(&mut self, observer: Rc>) { + let observer_name = observer.borrow().name().to_string(); + self.observers.push(Rc::downgrade(&observer)); + println!("Observer '{}' registered", observer_name); + } + + fn remove_observer(&mut self, observer_to_remove: &Rc>) { + let observer_name = observer_to_remove.borrow().name().to_string(); + let initial_count = self.observers.len(); + + // Filter out the observer to remove and any weak references that can't be upgraded + self.observers.retain(|weak_observer| { + if let Some(observer) = weak_observer.upgrade() { + // Keep if it's not the one we want to remove + !Rc::ptr_eq(&observer, observer_to_remove) + } else { + // Remove if the weak reference can't be upgraded + false + } + }); + + if self.observers.len() < initial_count { + println!("Observer '{}' removed", observer_name); + } + } + + fn notify_observers(&self) { + // Create a new vector to hold valid observers + let mut valid_observers = Vec::new(); + + // Process each observer + for weak_observer in &self.observers { + if let Some(observer) = weak_observer.upgrade() { + // Notify the observer + observer.borrow_mut().update(self.temperature, self.humidity, self.pressure); + // Keep this observer + valid_observers.push(Weak::clone(weak_observer)); + } + } + } +} + +// ========== Display Implementations ========== + +/// CurrentConditionsDisplay implements the Observer trait +struct CurrentConditionsDisplay { + name: String, + temperature: f32, + humidity: f32, +} + +impl CurrentConditionsDisplay { + /// Create a new CurrentConditionsDisplay instance + fn new(name: &str) -> Self { + CurrentConditionsDisplay { + name: name.to_string(), + temperature: 0.0, + humidity: 0.0, + } + } + + /// Display the current conditions + fn display(&self) { + println!("[{}] Current conditions: {:.1}°F and {:.1}% humidity", + self.name, self.temperature, self.humidity); + } +} + +impl Observer for CurrentConditionsDisplay { + fn update(&mut self, temperature: f32, humidity: f32, _pressure: f32) { + self.temperature = temperature; + self.humidity = humidity; + self.display(); + } + + fn name(&self) -> &str { + &self.name + } +} + +/// StatisticsDisplay implements the Observer trait +struct StatisticsDisplay { + name: String, + max_temp: f32, + min_temp: f32, + temp_sum: f32, + num_readings: u32, +} + +impl StatisticsDisplay { + /// Create a new StatisticsDisplay instance + fn new(name: &str) -> Self { + StatisticsDisplay { + name: name.to_string(), + max_temp: 0.0, + min_temp: 200.0, // Start with a high value + temp_sum: 0.0, + num_readings: 0, + } + } + + /// Display the statistics + fn display(&self) { + let avg_temp = self.temp_sum / self.num_readings as f32; + println!("[{}] Avg/Max/Min temperature: {:.1}/{:.1}/{:.1}", + self.name, avg_temp, self.max_temp, self.min_temp); + } +} + +impl Observer for StatisticsDisplay { + fn update(&mut self, temperature: f32, _humidity: f32, _pressure: f32) { + self.temp_sum += temperature; + self.num_readings += 1; + + if temperature > self.max_temp { + self.max_temp = temperature; + } + + if temperature < self.min_temp { + self.min_temp = temperature; + } + + self.display(); + } + + fn name(&self) -> &str { + &self.name + } +} + +/// ForecastDisplay implements the Observer trait +struct ForecastDisplay { + name: String, + current_pressure: f32, + last_pressure: f32, +} + +impl ForecastDisplay { + /// Create a new ForecastDisplay instance + fn new(name: &str) -> Self { + ForecastDisplay { + name: name.to_string(), + current_pressure: 29.92, // Default starting pressure + last_pressure: 0.0, + } + } + + /// Display the forecast + fn display(&self) { + print!("[{}] Forecast: ", self.name); + + if self.current_pressure > self.last_pressure { + println!("Improving weather on the way!"); + } else if self.current_pressure == self.last_pressure { + println!("More of the same"); + } else { + println!("Watch out for cooler, rainy weather"); + } + } +} + +impl Observer for ForecastDisplay { + fn update(&mut self, _temperature: f32, _humidity: f32, pressure: f32) { + self.last_pressure = self.current_pressure; + self.current_pressure = pressure; + self.display(); + } + + fn name(&self) -> &str { + &self.name + } +} + +/// HeatIndexDisplay implements the Observer trait +struct HeatIndexDisplay { + name: String, + heat_index: f32, +} + +impl HeatIndexDisplay { + /// Create a new HeatIndexDisplay instance + fn new(name: &str) -> Self { + HeatIndexDisplay { + name: name.to_string(), + heat_index: 0.0, + } + } + + /// Compute the heat index based on temperature and humidity + fn compute_heat_index(t: f32, rh: f32) -> f32 { + // This is a simplified formula for heat index + (16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh) + + (0.00941695 * (t * t)) + (0.00728898 * (rh * rh)) + + (0.000345372 * (t * t * rh)) - (0.000814971 * (t * rh * rh)) + + (0.0000102102 * (t * t * rh * rh)) - (0.000038646 * (t * t * t)) + + (0.0000291583 * (rh * rh * rh)) + (0.00000142721 * (t * t * t * rh)) + + (0.000000197483 * (t * rh * rh * rh)) - (0.0000000218429 * (t * t * t * rh * rh)) + + 0.000000000843296 * (t * t * rh * rh * rh)) - + (0.0000000000481975 * (t * t * t * rh * rh * rh)) + } + + /// Display the heat index + fn display(&self) { + println!("[{}] Heat index: {:.1}", self.name, self.heat_index); + } +} + +impl Observer for HeatIndexDisplay { + fn update(&mut self, temperature: f32, humidity: f32, _pressure: f32) { + self.heat_index = Self::compute_heat_index(temperature, humidity); + self.display(); + } + + fn name(&self) -> &str { + &self.name + } +} + +// ========== Demo Code ========== + +/// Run the weather station demo +fn run_weather_station() { + // Create the WeatherData subject + let mut weather_data = WeatherData::new(); + + // Create display devices (observers) + let current_display = Rc::new(RefCell::new(CurrentConditionsDisplay::new("Current Display"))); + let stats_display = Rc::new(RefCell::new(StatisticsDisplay::new("Statistics Display"))); + let forecast_display = Rc::new(RefCell::new(ForecastDisplay::new("Forecast Display"))); + let heat_index_display = Rc::new(RefCell::new(HeatIndexDisplay::new("Heat Index Display"))); + + // Register observers + weather_data.register_observer(Rc::clone(¤t_display)); + weather_data.register_observer(Rc::clone(&stats_display)); + weather_data.register_observer(Rc::clone(&forecast_display)); + weather_data.register_observer(Rc::clone(&heat_index_display)); + + println!("\n=== First Weather Update ==="); + // Simulate new weather measurements + weather_data.set_measurements(80.0, 65.0, 30.4); + + println!("\n=== Second Weather Update ==="); + // Simulate new weather measurements + weather_data.set_measurements(82.0, 70.0, 29.2); + + println!("\n=== Third Weather Update ==="); + // Simulate new weather measurements + weather_data.set_measurements(78.0, 90.0, 29.2); + + println!("\n=== Removing an Observer ==="); + // Remove an observer + weather_data.remove_observer(&forecast_display); + + println!("\n=== Fourth Weather Update ==="); + // One more measurement after removing an observer + weather_data.set_measurements(75.0, 60.0, 30.1); +} + +fn main() { + // Run the demo + run_weather_station(); +} diff --git a/snippets/design-patterns/singleton/SingletonPattern.cpp b/snippets/design-patterns/singleton/SingletonPattern.cpp new file mode 100644 index 0000000..e29695a --- /dev/null +++ b/snippets/design-patterns/singleton/SingletonPattern.cpp @@ -0,0 +1,369 @@ +/** + * Singleton Pattern Implementation in C++ + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in C++. + */ + +#include +#include +#include +#include +#include +#include +#include + +// ========== Classic Singleton Implementation ========== + +/** + * Classic Singleton implementation with lazy initialization + */ +class ClassicSingleton { +private: + // Private constructor to prevent direct instantiation + ClassicSingleton() { + timestamp_ = std::chrono::system_clock::now(); + std::cout << "ClassicSingleton instance created." << std::endl; + } + + // Delete copy constructor and assignment operator + ClassicSingleton(const ClassicSingleton&) = delete; + ClassicSingleton& operator=(const ClassicSingleton&) = delete; + + // Static instance pointer + static ClassicSingleton* instance_; + + // Member variables + std::chrono::system_clock::time_point timestamp_; + std::map config_ = { + {"api_url", "https://api.example.com"}, + {"timeout", "3000"}, + {"retries", "3"} + }; + +public: + // Static method to get the singleton instance + static ClassicSingleton* getInstance() { + if (instance_ == nullptr) { + instance_ = new ClassicSingleton(); + } + return instance_; + } + + // Clean up the singleton instance + static void destroyInstance() { + delete instance_; + instance_ = nullptr; + } + + // Get configuration + std::map getConfig() const { + return config_; + } + + // Update configuration + void updateConfig(const std::string& key, const std::string& value) { + config_[key] = value; + std::cout << "Configuration updated: " << key << " = " << value << std::endl; + } + + // Get creation timestamp + std::chrono::system_clock::time_point getTimestamp() const { + return timestamp_; + } +}; + +// Initialize the static instance pointer +ClassicSingleton* ClassicSingleton::instance_ = nullptr; + +// ========== Thread-Safe Singleton Implementation ========== + +/** + * Thread-safe Singleton implementation with double-checked locking + */ +class ThreadSafeSingleton { +private: + // Private constructor to prevent direct instantiation + ThreadSafeSingleton() { + std::cout << "ThreadSafeSingleton instance created." << std::endl; + } + + // Delete copy constructor and assignment operator + ThreadSafeSingleton(const ThreadSafeSingleton&) = delete; + ThreadSafeSingleton& operator=(const ThreadSafeSingleton&) = delete; + + // Static instance pointer + static ThreadSafeSingleton* instance_; + static std::mutex mutex_; + + // Member variables + std::vector logs_; + +public: + // Static method to get the singleton instance (thread-safe) + static ThreadSafeSingleton* getInstance() { + if (instance_ == nullptr) { + std::lock_guard lock(mutex_); + if (instance_ == nullptr) { + instance_ = new ThreadSafeSingleton(); + } + } + return instance_; + } + + // Clean up the singleton instance + static void destroyInstance() { + std::lock_guard lock(mutex_); + delete instance_; + instance_ = nullptr; + } + + // Log a message + void log(const std::string& message) { + std::lock_guard lock(mutex_); + auto now = std::chrono::system_clock::now(); + auto now_c = std::chrono::system_clock::to_time_t(now); + std::string timestamp = std::ctime(&now_c); + timestamp.pop_back(); // Remove trailing newline + + std::string logEntry = timestamp + ": " + message; + logs_.push_back(logEntry); + std::cout << logEntry << std::endl; + } + + // Get all logs + std::vector getLogs() const { + std::lock_guard lock(mutex_); + return logs_; + } + + // Clear logs + void clearLogs() { + std::lock_guard lock(mutex_); + logs_.clear(); + std::cout << "Logs cleared." << std::endl; + } +}; + +// Initialize static members +ThreadSafeSingleton* ThreadSafeSingleton::instance_ = nullptr; +std::mutex ThreadSafeSingleton::mutex_; + +// ========== Modern C++ Singleton Implementation (Meyers Singleton) ========== + +/** + * Modern C++ Singleton implementation using static local variable (Scott Meyers Singleton) + * This is thread-safe in C++11 and later + */ +class MeyersSingleton { +private: + // Private constructor to prevent direct instantiation + MeyersSingleton() { + std::cout << "MeyersSingleton instance created." << std::endl; + } + + // Delete copy constructor and assignment operator + MeyersSingleton(const MeyersSingleton&) = delete; + MeyersSingleton& operator=(const MeyersSingleton&) = delete; + + // Member variables + struct DatabaseConnection { + bool connected = false; + std::string connectionString; + int connectionCount = 0; + }; + + DatabaseConnection db_; + +public: + // Static method to get the singleton instance + static MeyersSingleton& getInstance() { + // Static local variable is initialized only once in a thread-safe way + static MeyersSingleton instance; + return instance; + } + + // Connect to database + bool connect(const std::string& connectionString) { + if (db_.connected) { + db_.connectionCount++; + std::cout << "Already connected to database. Connection count: " << db_.connectionCount << std::endl; + return true; + } + + // Simulate connection + db_.connectionString = connectionString; + db_.connected = true; + db_.connectionCount = 1; + std::cout << "Connected to database: " << connectionString << std::endl; + return true; + } + + // Disconnect from database + bool disconnect() { + if (!db_.connected) { + std::cout << "Not connected to any database." << std::endl; + return false; + } + + db_.connectionCount--; + if (db_.connectionCount == 0) { + db_.connected = false; + std::cout << "Disconnected from database: " << db_.connectionString << std::endl; + } else { + std::cout << "Connection count decreased. Remaining connections: " << db_.connectionCount << std::endl; + } + + return true; + } + + // Get connection status + bool isConnected() const { + return db_.connected; + } + + // Get connection count + int getConnectionCount() const { + return db_.connectionCount; + } +}; + +// ========== Singleton with Shared Pointer ========== + +/** + * Singleton implementation using std::shared_ptr for automatic memory management + */ +class SharedPtrSingleton { +private: + // Private constructor to prevent direct instantiation + SharedPtrSingleton() { + std::cout << "SharedPtrSingleton instance created." << std::endl; + } + + // Delete copy constructor and assignment operator + SharedPtrSingleton(const SharedPtrSingleton&) = delete; + SharedPtrSingleton& operator=(const SharedPtrSingleton&) = delete; + + // Static instance pointer + static std::shared_ptr instance_; + static std::mutex mutex_; + + // Member variables + std::map featureFlags_ = { + {"dark_mode", false}, + {"beta_features", false}, + {"analytics", true}, + {"notifications", true} + }; + +public: + // Static method to get the singleton instance + static std::shared_ptr getInstance() { + std::lock_guard lock(mutex_); + if (!instance_) { + instance_ = std::shared_ptr(new SharedPtrSingleton()); + } + return instance_; + } + + // Enable a feature + void enableFeature(const std::string& featureName) { + featureFlags_[featureName] = true; + std::cout << "Feature enabled: " << featureName << std::endl; + } + + // Disable a feature + void disableFeature(const std::string& featureName) { + featureFlags_[featureName] = false; + std::cout << "Feature disabled: " << featureName << std::endl; + } + + // Check if a feature is enabled + bool isFeatureEnabled(const std::string& featureName) const { + auto it = featureFlags_.find(featureName); + if (it != featureFlags_.end()) { + return it->second; + } + return false; + } + + // Get all feature flags + std::map getAllFeatureFlags() const { + return featureFlags_; + } +}; + +// Initialize static members +std::shared_ptr SharedPtrSingleton::instance_ = nullptr; +std::mutex SharedPtrSingleton::mutex_; + +// ========== Demo Code ========== + +void demonstrateSingletons() { + std::cout << "===== Classic Singleton Demo =====" << std::endl; + ClassicSingleton* singleton1 = ClassicSingleton::getInstance(); + ClassicSingleton* singleton2 = ClassicSingleton::getInstance(); + + std::cout << "Are instances the same? " << (singleton1 == singleton2 ? "Yes" : "No") << std::endl; + + auto config = singleton1->getConfig(); + std::cout << "Original config: api_url = " << config["api_url"] << std::endl; + + singleton2->updateConfig("timeout", "5000"); + config = singleton1->getConfig(); + std::cout << "Updated config from singleton1: timeout = " << config["timeout"] << std::endl; + + std::cout << "\n===== Thread-Safe Singleton Demo =====" << std::endl; + ThreadSafeSingleton* logger1 = ThreadSafeSingleton::getInstance(); + ThreadSafeSingleton* logger2 = ThreadSafeSingleton::getInstance(); + + std::cout << "Are instances the same? " << (logger1 == logger2 ? "Yes" : "No") << std::endl; + + logger1->log("Application started"); + logger1->log("Processing data"); + logger2->log("Operation completed"); + + auto logs = logger1->getLogs(); + std::cout << "Log count: " << logs.size() << std::endl; + + std::cout << "\n===== Meyers Singleton Demo =====" << std::endl; + MeyersSingleton& db1 = MeyersSingleton::getInstance(); + MeyersSingleton& db2 = MeyersSingleton::getInstance(); + + std::cout << "Are instances the same? " << (&db1 == &db2 ? "Yes" : "No") << std::endl; + + db1.connect("mysql://localhost:3306/mydb"); + db2.connect("mysql://localhost:3306/mydb"); + std::cout << "Connection count: " << db1.getConnectionCount() << std::endl; + + db1.disconnect(); + std::cout << "Is still connected? " << (db2.isConnected() ? "Yes" : "No") << std::endl; + + std::cout << "\n===== Shared Pointer Singleton Demo =====" << std::endl; + auto featureManager1 = SharedPtrSingleton::getInstance(); + auto featureManager2 = SharedPtrSingleton::getInstance(); + + std::cout << "Are instances the same? " << (featureManager1 == featureManager2 ? "Yes" : "No") << std::endl; + + std::cout << "Dark mode enabled: " << (featureManager1->isFeatureEnabled("dark_mode") ? "Yes" : "No") << std::endl; + + featureManager2->enableFeature("dark_mode"); + std::cout << "Dark mode enabled after update: " << (featureManager1->isFeatureEnabled("dark_mode") ? "Yes" : "No") << std::endl; + + // Clean up classic singleton + ClassicSingleton::destroyInstance(); + ThreadSafeSingleton::destroyInstance(); + // No need to clean up Meyers Singleton or SharedPtrSingleton +} + +// Main function +int main() { + std::cout << "Singleton Pattern Demonstration in C++\n"; + std::cout << "====================================\n\n"; + + demonstrateSingletons(); + return 0; +} \ No newline at end of file diff --git a/snippets/design-patterns/singleton/SingletonPattern.cs b/snippets/design-patterns/singleton/SingletonPattern.cs new file mode 100644 index 0000000..47bc89b --- /dev/null +++ b/snippets/design-patterns/singleton/SingletonPattern.cs @@ -0,0 +1,500 @@ +/** + * Singleton Pattern Implementation in C# + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in C#. + */ + +using System; +using System.Collections.Generic; +using System.Threading; + +namespace DesignPatterns.Singleton +{ + // ========== Classic Singleton Implementation ========== + + /// + /// Classic Singleton implementation using a static instance field and lazy initialization + /// + public sealed class ClassicSingleton + { + private static ClassicSingleton _instance; + private static readonly object _lock = new object(); + + private DateTime _timestamp; + private Dictionary _config; + + // Private constructor to prevent direct instantiation + private ClassicSingleton() + { + _timestamp = DateTime.Now; + _config = new Dictionary + { + { "ApiUrl", "https://api.example.com" }, + { "Timeout", 3000 }, + { "Retries", 3 } + }; + } + + public static ClassicSingleton Instance + { + get + { + if (_instance == null) + { + lock (_lock) + { + if (_instance == null) + { + _instance = new ClassicSingleton(); + } + } + } + return _instance; + } + } + + public Dictionary GetConfig() + { + return new Dictionary(_config); + } + + public void UpdateConfig(string key, object value) + { + lock (_lock) + { + _config[key] = value; + Console.WriteLine($"Configuration updated: {key} = {value}"); + } + } + + public DateTime GetTimestamp() + { + return _timestamp; + } + } + + // ========== Singleton with Static Initialization ========== + + /// + /// Singleton implementation using static initialization + /// This implementation is thread-safe without explicit synchronization + /// + public sealed class StaticSingleton + { + // Static initialization is thread-safe in C# + private static readonly StaticSingleton _instance = new StaticSingleton(); + + private int _connectionCount; + private bool _isConnected; + private string _connectionString; + + // Static constructor to tell C# compiler not to mark type as beforefieldinit + static StaticSingleton() + { + } + + // Private constructor to prevent direct instantiation + private StaticSingleton() + { + _connectionCount = 0; + _isConnected = false; + _connectionString = string.Empty; + } + + public static StaticSingleton Instance + { + get { return _instance; } + } + + public bool Connect(string connectionString) + { + if (_isConnected) + { + _connectionCount++; + Console.WriteLine($"Already connected to database. Connection count: {_connectionCount}"); + return true; + } + + // Simulate connection + _connectionString = connectionString; + _isConnected = true; + _connectionCount = 1; + Console.WriteLine($"Connected to database: {connectionString}"); + return true; + } + + public bool Disconnect() + { + if (!_isConnected) + { + Console.WriteLine("Not connected to any database."); + return false; + } + + _connectionCount--; + if (_connectionCount == 0) + { + _isConnected = false; + Console.WriteLine($"Disconnected from database: {_connectionString}"); + } + else + { + Console.WriteLine($"Connection count decreased. Remaining connections: {_connectionCount}"); + } + + return true; + } + + public bool IsConnected => _isConnected; + + public int ConnectionCount => _connectionCount; + } + + // ========== Singleton with Lazy ========== + + /// + /// Modern Singleton implementation using Lazy + /// This implementation is thread-safe and uses .NET's built-in lazy initialization + /// + public sealed class LazySingleton + { + private static readonly Lazy _lazy = + new Lazy(() => new LazySingleton()); + + private List _logs; + + private LazySingleton() + { + _logs = new List(); + } + + public static LazySingleton Instance => _lazy.Value; + + public void Log(string message) + { + string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); + string logEntry = $"{timestamp}: {message}"; + _logs.Add(logEntry); + Console.WriteLine(logEntry); + } + + public void Warn(string message) + { + Log($"WARNING: {message}"); + } + + public void Error(string message) + { + Log($"ERROR: {message}"); + } + + public List GetLogs() + { + return new List(_logs); + } + + public void ClearLogs() + { + _logs.Clear(); + Console.WriteLine("Logs cleared"); + } + } + + // ========== Singleton with Dependency Injection ========== + + /// + /// Singleton implementation that can be used with dependency injection + /// This is a more modern approach that allows for better testability + /// + public interface IConfigManager + { + Dictionary GetConfig(); + void SetConfig(string key, object value); + void ResetConfig(); + } + + public sealed class ConfigManager : IConfigManager + { + private Dictionary _config; + + public ConfigManager() + { + _config = new Dictionary + { + { "Theme", "light" }, + { "Language", "en" }, + { "Notifications", true }, + { "AutoSave", true } + }; + } + + public Dictionary GetConfig() + { + return new Dictionary(_config); + } + + public void SetConfig(string key, object value) + { + _config[key] = value; + Console.WriteLine($"Configuration updated: {key} = {value}"); + } + + public void ResetConfig() + { + _config = new Dictionary + { + { "Theme", "light" }, + { "Language", "en" }, + { "Notifications", true }, + { "AutoSave", true } + }; + Console.WriteLine("Configuration reset to defaults"); + } + } + + // ========== Thread-Safe Singleton with Double-Check Locking ========== + + /// + /// Thread-safe Singleton implementation using double-check locking + /// + public sealed class UserManager + { + private static volatile UserManager _instance; + private static readonly object _lock = new object(); + + private readonly Dictionary _users; + + // Private constructor to prevent direct instantiation + private UserManager() + { + _users = new Dictionary(); + } + + public static UserManager Instance + { + get + { + if (_instance == null) + { + lock (_lock) + { + if (_instance == null) + { + _instance = new UserManager(); + } + } + } + return _instance; + } + } + + public bool AddUser(int id, UserData userData) + { + lock (_lock) + { + if (_users.ContainsKey(id)) + { + throw new InvalidOperationException($"User with ID {id} already exists"); + } + + _users[id] = new UserData + { + Name = userData.Name, + Email = userData.Email, + CreatedAt = DateTime.Now + }; + + return true; + } + } + + public UserData GetUser(int id) + { + lock (_lock) + { + if (!_users.ContainsKey(id)) + { + return null; + } + + // Return a copy to prevent modification + return new UserData + { + Name = _users[id].Name, + Email = _users[id].Email, + Role = _users[id].Role, + CreatedAt = _users[id].CreatedAt, + UpdatedAt = _users[id].UpdatedAt + }; + } + } + + public bool UpdateUser(int id, UserData userData) + { + lock (_lock) + { + if (!_users.ContainsKey(id)) + { + throw new InvalidOperationException($"User with ID {id} does not exist"); + } + + var existingUser = _users[id]; + _users[id] = new UserData + { + Name = userData.Name ?? existingUser.Name, + Email = userData.Email ?? existingUser.Email, + Role = userData.Role ?? existingUser.Role, + CreatedAt = existingUser.CreatedAt, + UpdatedAt = DateTime.Now + }; + + return true; + } + } + + public bool DeleteUser(int id) + { + lock (_lock) + { + if (!_users.ContainsKey(id)) + { + throw new InvalidOperationException($"User with ID {id} does not exist"); + } + + return _users.Remove(id); + } + } + + public List GetAllUsers() + { + lock (_lock) + { + var result = new List(); + foreach (var kvp in _users) + { + result.Add(new UserData + { + Id = kvp.Key, + Name = kvp.Value.Name, + Email = kvp.Value.Email, + Role = kvp.Value.Role, + CreatedAt = kvp.Value.CreatedAt, + UpdatedAt = kvp.Value.UpdatedAt + }); + } + return result; + } + } + + public int UserCount + { + get + { + lock (_lock) + { + return _users.Count; + } + } + } + } + + public class UserData + { + public int Id { get; set; } + public string Name { get; set; } + public string Email { get; set; } + public string Role { get; set; } + public DateTime CreatedAt { get; set; } + public DateTime? UpdatedAt { get; set; } + } + + // ========== Demo Code ========== + + public class SingletonDemo + { + public static void DemonstrateSingletons() + { + Console.WriteLine("===== Classic Singleton Demo ====="); + ClassicSingleton singleton1 = ClassicSingleton.Instance; + ClassicSingleton singleton2 = ClassicSingleton.Instance; + + Console.WriteLine($"Are instances the same? {object.ReferenceEquals(singleton1, singleton2)}"); + Console.WriteLine($"Instance timestamp: {singleton1.GetTimestamp()}"); + + var config = singleton1.GetConfig(); + Console.WriteLine($"Original config: ApiUrl = {config["ApiUrl"]}"); + + singleton2.UpdateConfig("Timeout", 5000); + config = singleton1.GetConfig(); + Console.WriteLine($"Updated config from singleton1: Timeout = {config["Timeout"]}"); + + Console.WriteLine("\n===== Static Singleton Demo ====="); + StaticSingleton db1 = StaticSingleton.Instance; + StaticSingleton db2 = StaticSingleton.Instance; + + Console.WriteLine($"Are instances the same? {object.ReferenceEquals(db1, db2)}"); + + db1.Connect("mysql://localhost:3306/mydb"); + db2.Connect("mysql://localhost:3306/mydb"); + Console.WriteLine($"Connection count: {db1.ConnectionCount}"); + + db1.Disconnect(); + Console.WriteLine($"Still connected? {db2.IsConnected}"); + + Console.WriteLine("\n===== Lazy Singleton Demo ====="); + LazySingleton logger1 = LazySingleton.Instance; + LazySingleton logger2 = LazySingleton.Instance; + + Console.WriteLine($"Are instances the same? {object.ReferenceEquals(logger1, logger2)}"); + + logger1.Log("Application started"); + logger1.Warn("Resource usage is high"); + logger2.Error("Failed to connect to service"); + + var logs = logger2.GetLogs(); + Console.WriteLine($"Log entries: {logs.Count}"); + + Console.WriteLine("\n===== Config Manager Demo ====="); + IConfigManager configManager = new ConfigManager(); + + var configSettings = configManager.GetConfig(); + Console.WriteLine($"Config value: Theme = {configSettings["Theme"]}"); + + configManager.SetConfig("Theme", "dark"); + configSettings = configManager.GetConfig(); + Console.WriteLine($"Updated config: Theme = {configSettings["Theme"]}"); + + Console.WriteLine("\n===== User Manager Singleton Demo ====="); + UserManager userManager1 = UserManager.Instance; + UserManager userManager2 = UserManager.Instance; + + Console.WriteLine($"Are instances the same? {object.ReferenceEquals(userManager1, userManager2)}"); + + userManager1.AddUser(1, new UserData { Name = "Alice", Email = "alice@example.com" }); + userManager1.AddUser(2, new UserData { Name = "Bob", Email = "bob@example.com" }); + + Console.WriteLine($"User count: {userManager2.UserCount}"); + + var user = userManager2.GetUser(1); + Console.WriteLine($"User #1: {user.Name}, {user.Email}"); + + userManager2.UpdateUser(1, new UserData { Role = "admin" }); + user = userManager1.GetUser(1); + Console.WriteLine($"Updated User #1: {user.Name}, {user.Email}, {user.Role}"); + } + } + + // Main program, run the example + class Program + { + static void Main(string[] args) + { + SingletonDemo.DemonstrateSingletons(); + Console.ReadLine(); + } + } +} diff --git a/snippets/design-patterns/singleton/SingletonPattern.java b/snippets/design-patterns/singleton/SingletonPattern.java new file mode 100644 index 0000000..f80e61e --- /dev/null +++ b/snippets/design-patterns/singleton/SingletonPattern.java @@ -0,0 +1,296 @@ +/** + * Singleton Pattern Implementation in Java + * + * This demonstrates various implementations of the Singleton pattern in Java. + */ + +import java.util.concurrent.atomic.AtomicReference; + +// Method 1: Eager Initialization +class EagerSingleton { + // Instance is created when class is loaded + private static final EagerSingleton INSTANCE = new EagerSingleton(); + + private int value = 0; + + // Private constructor prevents instantiation from other classes + private EagerSingleton() { + System.out.println("EagerSingleton instance created"); + } + + // Public static method to provide access to the instance + public static EagerSingleton getInstance() { + return INSTANCE; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 2: Lazy Initialization (not thread-safe) +class LazySingleton { + // Instance is not created until getInstance() is called + private static LazySingleton instance; + + private int value = 0; + + private LazySingleton() { + System.out.println("LazySingleton instance created"); + } + + // Not thread-safe! + public static LazySingleton getInstance() { + if (instance == null) { + instance = new LazySingleton(); + } + return instance; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 3: Thread-safe Lazy Initialization with synchronized method +class ThreadSafeSingleton { + private static ThreadSafeSingleton instance; + + private int value = 0; + + private ThreadSafeSingleton() { + System.out.println("ThreadSafeSingleton instance created"); + } + + // Thread-safe but has performance overhead + public static synchronized ThreadSafeSingleton getInstance() { + if (instance == null) { + instance = new ThreadSafeSingleton(); + } + return instance; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 4: Double-checked Locking +class DCLSingleton { + // volatile ensures visibility across threads + private static volatile DCLSingleton instance; + + private int value = 0; + + private DCLSingleton() { + System.out.println("DCLSingleton instance created"); + } + + // Thread-safe with better performance + public static DCLSingleton getInstance() { + // First check without synchronization + if (instance == null) { + // Synchronize only when instance is null + synchronized (DCLSingleton.class) { + // Double-check inside synchronized block + if (instance == null) { + instance = new DCLSingleton(); + } + } + } + return instance; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 5: Initialization on Demand Holder idiom +class HolderSingleton { + private int value = 0; + + private HolderSingleton() { + System.out.println("HolderSingleton instance created"); + } + + // Static holder class is only initialized when getInstance() is called + private static class Holder { + private static final HolderSingleton INSTANCE = new HolderSingleton(); + } + + // Thread-safe without synchronization overhead + public static HolderSingleton getInstance() { + return Holder.INSTANCE; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 6: Enum-based Singleton (serialization-safe and reflection-proof) +enum EnumSingleton { + INSTANCE; + + private int value = 0; + + EnumSingleton() { + System.out.println("EnumSingleton instance created"); + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Method 7: Using CAS (Compare-And-Swap) operations with AtomicReference +class CASSingleton { + private static final AtomicReference INSTANCE = new AtomicReference<>(); + + private int value = 0; + + private CASSingleton() { + System.out.println("CASSingleton instance created"); + } + + // Thread-safe using non-blocking synchronization + public static CASSingleton getInstance() { + CASSingleton instance = INSTANCE.get(); + if (instance == null) { + CASSingleton newInstance = new CASSingleton(); + if (INSTANCE.compareAndSet(null, newInstance)) { + instance = newInstance; + } else { + // Another thread beat us to it + instance = INSTANCE.get(); + } + } + return instance; + } + + public int increment() { + return ++value; + } + + public int getValue() { + return value; + } +} + +// Main class to demonstrate various singleton implementations +public class SingletonPattern { + public static void main(String[] args) { + System.out.println("Singleton Pattern Demonstrations"); + System.out.println("==============================="); + + demonstrateEagerSingleton(); + demonstrateLazySingleton(); + demonstrateThreadSafeSingleton(); + demonstrateDCLSingleton(); + demonstrateHolderSingleton(); + demonstrateEnumSingleton(); + demonstrateCASSingleton(); + } + + private static void demonstrateEagerSingleton() { + System.out.println("\n=== Eager Singleton ==="); + EagerSingleton s1 = EagerSingleton.getInstance(); + EagerSingleton s2 = EagerSingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateLazySingleton() { + System.out.println("\n=== Lazy Singleton (not thread-safe) ==="); + LazySingleton s1 = LazySingleton.getInstance(); + LazySingleton s2 = LazySingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateThreadSafeSingleton() { + System.out.println("\n=== Thread-Safe Singleton ==="); + ThreadSafeSingleton s1 = ThreadSafeSingleton.getInstance(); + ThreadSafeSingleton s2 = ThreadSafeSingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateDCLSingleton() { + System.out.println("\n=== Double-Checked Locking Singleton ==="); + DCLSingleton s1 = DCLSingleton.getInstance(); + DCLSingleton s2 = DCLSingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateHolderSingleton() { + System.out.println("\n=== Initialization-on-demand Holder Singleton ==="); + HolderSingleton s1 = HolderSingleton.getInstance(); + HolderSingleton s2 = HolderSingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateEnumSingleton() { + System.out.println("\n=== Enum Singleton ==="); + EnumSingleton s1 = EnumSingleton.INSTANCE; + EnumSingleton s2 = EnumSingleton.INSTANCE; + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } + + private static void demonstrateCASSingleton() { + System.out.println("\n=== CAS (AtomicReference) Singleton ==="); + CASSingleton s1 = CASSingleton.getInstance(); + CASSingleton s2 = CASSingleton.getInstance(); + + System.out.println("s1 == s2: " + (s1 == s2)); + System.out.println("s1.increment(): " + s1.increment()); + System.out.println("s2.increment(): " + s2.increment()); + System.out.println("s1.getValue(): " + s1.getValue() + ", s2.getValue(): " + s2.getValue()); + } +} \ No newline at end of file diff --git a/snippets/design-patterns/singleton/singleton_pattern.c b/snippets/design-patterns/singleton/singleton_pattern.c new file mode 100644 index 0000000..b21bcce --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.c @@ -0,0 +1,599 @@ +/** + * Singleton Pattern Implementation in C + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in C. + * Note: Since C is not an object-oriented language, we use structs with function pointers + * to simulate classes and objects. + */ + +#include +#include +#include +#include +#include +#include + +// ========== Classic Singleton Implementation ========== + +// Configuration Manager Singleton +typedef struct { + char api_url[100]; + int timeout; + int retries; + time_t timestamp; +} ConfigManager; + +// Global static instance +static ConfigManager* config_manager_instance = NULL; +static pthread_mutex_t config_manager_mutex = PTHREAD_MUTEX_INITIALIZER; + +// Get singleton instance +ConfigManager* get_config_manager() { + if (config_manager_instance == NULL) { + pthread_mutex_lock(&config_manager_mutex); + if (config_manager_instance == NULL) { + config_manager_instance = (ConfigManager*)malloc(sizeof(ConfigManager)); + if (config_manager_instance == NULL) { + pthread_mutex_unlock(&config_manager_mutex); + return NULL; + } + + // Initialize default values + strcpy(config_manager_instance->api_url, "https://api.example.com"); + config_manager_instance->timeout = 3000; + config_manager_instance->retries = 3; + config_manager_instance->timestamp = time(NULL); + } + pthread_mutex_unlock(&config_manager_mutex); + } + + return config_manager_instance; +} + +// Get config values +void config_manager_get_config(ConfigManager* cm, char* api_url, int* timeout, int* retries) { + pthread_mutex_lock(&config_manager_mutex); + if (api_url != NULL) { + strcpy(api_url, cm->api_url); + } + if (timeout != NULL) { + *timeout = cm->timeout; + } + if (retries != NULL) { + *retries = cm->retries; + } + pthread_mutex_unlock(&config_manager_mutex); +} + +// Update config value +void config_manager_update_config(ConfigManager* cm, const char* key, const void* value) { + pthread_mutex_lock(&config_manager_mutex); + if (strcmp(key, "api_url") == 0 && value != NULL) { + strcpy(cm->api_url, (const char*)value); + printf("Configuration updated: api_url = %s\n", cm->api_url); + } else if (strcmp(key, "timeout") == 0 && value != NULL) { + cm->timeout = *((int*)value); + printf("Configuration updated: timeout = %d\n", cm->timeout); + } else if (strcmp(key, "retries") == 0 && value != NULL) { + cm->retries = *((int*)value); + printf("Configuration updated: retries = %d\n", cm->retries); + } + pthread_mutex_unlock(&config_manager_mutex); +} + +// Get timestamp +time_t config_manager_get_timestamp(ConfigManager* cm) { + return cm->timestamp; +} + +// Clean up resources +void config_manager_destroy() { + pthread_mutex_lock(&config_manager_mutex); + if (config_manager_instance != NULL) { + free(config_manager_instance); + config_manager_instance = NULL; + } + pthread_mutex_unlock(&config_manager_mutex); +} + +// ========== Database Connection Singleton ========== + +// Database Connection Singleton +typedef struct { + char connection_string[200]; + int connection_count; + bool is_connected; +} DatabaseConnection; + +// Global static instance +static DatabaseConnection* db_connection_instance = NULL; +static pthread_mutex_t db_connection_mutex = PTHREAD_MUTEX_INITIALIZER; + +// Get singleton instance +DatabaseConnection* get_database_connection() { + if (db_connection_instance == NULL) { + pthread_mutex_lock(&db_connection_mutex); + if (db_connection_instance == NULL) { + db_connection_instance = (DatabaseConnection*)malloc(sizeof(DatabaseConnection)); + if (db_connection_instance == NULL) { + pthread_mutex_unlock(&db_connection_mutex); + return NULL; + } + + // Initialize default values + db_connection_instance->connection_string[0] = '\0'; + db_connection_instance->connection_count = 0; + db_connection_instance->is_connected = false; + } + pthread_mutex_unlock(&db_connection_mutex); + } + + return db_connection_instance; +} + +// Connect to database +bool database_connection_connect(DatabaseConnection* db, const char* connection_string) { + pthread_mutex_lock(&db_connection_mutex); + if (db->is_connected) { + db->connection_count++; + printf("Already connected to database. Connection count: %d\n", db->connection_count); + pthread_mutex_unlock(&db_connection_mutex); + return true; + } + + // Simulate connection + strcpy(db->connection_string, connection_string); + db->is_connected = true; + db->connection_count = 1; + printf("Connected to database: %s\n", connection_string); + pthread_mutex_unlock(&db_connection_mutex); + return true; +} + +// Disconnect from database +bool database_connection_disconnect(DatabaseConnection* db) { + pthread_mutex_lock(&db_connection_mutex); + if (!db->is_connected) { + printf("Not connected to any database.\n"); + pthread_mutex_unlock(&db_connection_mutex); + return false; + } + + db->connection_count--; + if (db->connection_count == 0) { + db->is_connected = false; + printf("Disconnected from database: %s\n", db->connection_string); + } else { + printf("Connection count decreased. Remaining connections: %d\n", db->connection_count); + } + pthread_mutex_unlock(&db_connection_mutex); + return true; +} + +// Check if connected +bool database_connection_is_connected(DatabaseConnection* db) { + pthread_mutex_lock(&db_connection_mutex); + bool result = db->is_connected; + pthread_mutex_unlock(&db_connection_mutex); + return result; +} + +// Get connection count +int database_connection_get_count(DatabaseConnection* db) { + pthread_mutex_lock(&db_connection_mutex); + int result = db->connection_count; + pthread_mutex_unlock(&db_connection_mutex); + return result; +} + +// Clean up resources +void database_connection_destroy() { + pthread_mutex_lock(&db_connection_mutex); + if (db_connection_instance != NULL) { + free(db_connection_instance); + db_connection_instance = NULL; + } + pthread_mutex_unlock(&db_connection_mutex); +} + +// ========== Logger Singleton ========== + +// Log entry structure +typedef struct LogEntry { + char message[256]; + time_t timestamp; + struct LogEntry* next; +} LogEntry; + +// Logger Singleton +typedef struct { + LogEntry* head; + int log_count; +} Logger; + +// Global static instance +static Logger* logger_instance = NULL; +static pthread_mutex_t logger_mutex = PTHREAD_MUTEX_INITIALIZER; + +// Get singleton instance +Logger* get_logger() { + if (logger_instance == NULL) { + pthread_mutex_lock(&logger_mutex); + if (logger_instance == NULL) { + logger_instance = (Logger*)malloc(sizeof(Logger)); + if (logger_instance == NULL) { + pthread_mutex_unlock(&logger_mutex); + return NULL; + } + + // Initialize default values + logger_instance->head = NULL; + logger_instance->log_count = 0; + } + pthread_mutex_unlock(&logger_mutex); + } + + return logger_instance; +} + +// Add log entry +void logger_log(Logger* logger, const char* message) { + time_t now = time(NULL); + struct tm* tm_info = localtime(&now); + char timestamp[26]; + strftime(timestamp, 26, "%Y-%m-%d %H:%M:%S", tm_info); + + LogEntry* new_entry = (LogEntry*)malloc(sizeof(LogEntry)); + if (new_entry == NULL) { + return; + } + + snprintf(new_entry->message, sizeof(new_entry->message), "%s: %s", timestamp, message); + new_entry->timestamp = now; + new_entry->next = NULL; + + pthread_mutex_lock(&logger_mutex); + if (logger->head == NULL) { + logger->head = new_entry; + } else { + LogEntry* current = logger->head; + while (current->next != NULL) { + current = current->next; + } + current->next = new_entry; + } + logger->log_count++; + pthread_mutex_unlock(&logger_mutex); + + printf("%s\n", new_entry->message); +} + +// Add warning log entry +void logger_warn(Logger* logger, const char* message) { + char warning_message[256]; + snprintf(warning_message, sizeof(warning_message), "WARNING: %s", message); + logger_log(logger, warning_message); +} + +// Add error log entry +void logger_error(Logger* logger, const char* message) { + char error_message[256]; + snprintf(error_message, sizeof(error_message), "ERROR: %s", message); + logger_log(logger, error_message); +} + +// Get log count +int logger_get_count(Logger* logger) { + pthread_mutex_lock(&logger_mutex); + int result = logger->log_count; + pthread_mutex_unlock(&logger_mutex); + return result; +} + +// Clear logs +void logger_clear(Logger* logger) { + pthread_mutex_lock(&logger_mutex); + LogEntry* current = logger->head; + while (current != NULL) { + LogEntry* next = current->next; + free(current); + current = next; + } + logger->head = NULL; + logger->log_count = 0; + pthread_mutex_unlock(&logger_mutex); + printf("Logs cleared\n"); +} + +// Clean up resources +void logger_destroy() { + pthread_mutex_lock(&logger_mutex); + if (logger_instance != NULL) { + LogEntry* current = logger_instance->head; + while (current != NULL) { + LogEntry* next = current->next; + free(current); + current = next; + } + free(logger_instance); + logger_instance = NULL; + } + pthread_mutex_unlock(&logger_mutex); +} + +// ========== User Manager Singleton ========== + +// User structure +typedef struct { + int id; + char name[100]; + char email[100]; + char role[50]; + time_t created_at; + time_t updated_at; + bool has_role; +} User; + +// User Manager Singleton +typedef struct { + User* users; + int capacity; + int count; +} UserManager; + +// Global static instance +static UserManager* user_manager_instance = NULL; +static pthread_mutex_t user_manager_mutex = PTHREAD_MUTEX_INITIALIZER; + +// Get singleton instance +UserManager* get_user_manager() { + if (user_manager_instance == NULL) { + pthread_mutex_lock(&user_manager_mutex); + if (user_manager_instance == NULL) { + user_manager_instance = (UserManager*)malloc(sizeof(UserManager)); + if (user_manager_instance == NULL) { + pthread_mutex_unlock(&user_manager_mutex); + return NULL; + } + + // Initialize with capacity for 10 users + user_manager_instance->capacity = 10; + user_manager_instance->users = (User*)malloc(user_manager_instance->capacity * sizeof(User)); + if (user_manager_instance->users == NULL) { + free(user_manager_instance); + user_manager_instance = NULL; + pthread_mutex_unlock(&user_manager_mutex); + return NULL; + } + user_manager_instance->count = 0; + } + pthread_mutex_unlock(&user_manager_mutex); + } + + return user_manager_instance; +} + +// Find user by ID +int user_manager_find_user(UserManager* um, int id) { + for (int i = 0; i < um->count; i++) { + if (um->users[i].id == id) { + return i; + } + } + return -1; +} + +// Add user +bool user_manager_add_user(UserManager* um, int id, const char* name, const char* email) { + pthread_mutex_lock(&user_manager_mutex); + + // Check if user already exists + if (user_manager_find_user(um, id) != -1) { + printf("User with ID %d already exists\n", id); + pthread_mutex_unlock(&user_manager_mutex); + return false; + } + + // Check if we need to resize the array + if (um->count >= um->capacity) { + int new_capacity = um->capacity * 2; + User* new_users = (User*)realloc(um->users, new_capacity * sizeof(User)); + if (new_users == NULL) { + pthread_mutex_unlock(&user_manager_mutex); + return false; + } + um->users = new_users; + um->capacity = new_capacity; + } + + // Add the new user + User* new_user = &um->users[um->count]; + new_user->id = id; + strncpy(new_user->name, name, sizeof(new_user->name) - 1); + new_user->name[sizeof(new_user->name) - 1] = '\0'; + strncpy(new_user->email, email, sizeof(new_user->email) - 1); + new_user->email[sizeof(new_user->email) - 1] = '\0'; + new_user->role[0] = '\0'; + new_user->has_role = false; + new_user->created_at = time(NULL); + new_user->updated_at = 0; + + um->count++; + pthread_mutex_unlock(&user_manager_mutex); + return true; +} + +// Get user +User* user_manager_get_user(UserManager* um, int id) { + pthread_mutex_lock(&user_manager_mutex); + int index = user_manager_find_user(um, id); + if (index == -1) { + pthread_mutex_unlock(&user_manager_mutex); + return NULL; + } + + static User user_copy; + memcpy(&user_copy, &um->users[index], sizeof(User)); + pthread_mutex_unlock(&user_manager_mutex); + return &user_copy; +} + +// Update user +bool user_manager_update_user(UserManager* um, int id, const char* name, const char* email, const char* role) { + pthread_mutex_lock(&user_manager_mutex); + int index = user_manager_find_user(um, id); + if (index == -1) { + printf("User with ID %d does not exist\n", id); + pthread_mutex_unlock(&user_manager_mutex); + return false; + } + + User* user = &um->users[index]; + if (name != NULL) { + strncpy(user->name, name, sizeof(user->name) - 1); + user->name[sizeof(user->name) - 1] = '\0'; + } + if (email != NULL) { + strncpy(user->email, email, sizeof(user->email) - 1); + user->email[sizeof(user->email) - 1] = '\0'; + } + if (role != NULL) { + strncpy(user->role, role, sizeof(user->role) - 1); + user->role[sizeof(user->role) - 1] = '\0'; + user->has_role = true; + } + + user->updated_at = time(NULL); + pthread_mutex_unlock(&user_manager_mutex); + return true; +} + +// Delete user +bool user_manager_delete_user(UserManager* um, int id) { + pthread_mutex_lock(&user_manager_mutex); + int index = user_manager_find_user(um, id); + if (index == -1) { + printf("User with ID %d does not exist\n", id); + pthread_mutex_unlock(&user_manager_mutex); + return false; + } + + // Remove user by shifting all users after it + for (int i = index; i < um->count - 1; i++) { + um->users[i] = um->users[i + 1]; + } + + um->count--; + pthread_mutex_unlock(&user_manager_mutex); + return true; +} + +// Get user count +int user_manager_get_count(UserManager* um) { + pthread_mutex_lock(&user_manager_mutex); + int result = um->count; + pthread_mutex_unlock(&user_manager_mutex); + return result; +} + +// Clean up resources +void user_manager_destroy() { + pthread_mutex_lock(&user_manager_mutex); + if (user_manager_instance != NULL) { + if (user_manager_instance->users != NULL) { + free(user_manager_instance->users); + } + free(user_manager_instance); + user_manager_instance = NULL; + } + pthread_mutex_unlock(&user_manager_mutex); +} + +// ========== Demo Code ========== + +void demonstrate_singletons() { + printf("===== Config Manager Singleton Demo =====\n"); + ConfigManager* config1 = get_config_manager(); + ConfigManager* config2 = get_config_manager(); + + printf("Are instances the same? %s\n", (config1 == config2) ? "Yes" : "No"); + printf("Instance timestamp: %ld\n", config_manager_get_timestamp(config1)); + + char api_url[100]; + int timeout; + int retries; + config_manager_get_config(config1, api_url, &timeout, &retries); + printf("Original config: api_url = %s, timeout = %d, retries = %d\n", api_url, timeout, retries); + + int new_timeout = 5000; + config_manager_update_config(config2, "timeout", &new_timeout); + + config_manager_get_config(config1, api_url, &timeout, &retries); + printf("Updated config from config1: timeout = %d\n", timeout); + + printf("\n===== Database Connection Singleton Demo =====\n"); + DatabaseConnection* db1 = get_database_connection(); + DatabaseConnection* db2 = get_database_connection(); + + printf("Are instances the same? %s\n", (db1 == db2) ? "Yes" : "No"); + + database_connection_connect(db1, "mysql://localhost:3306/mydb"); + database_connection_connect(db2, "mysql://localhost:3306/mydb"); + printf("Connection count: %d\n", database_connection_get_count(db1)); + + database_connection_disconnect(db1); + printf("Still connected? %s\n", database_connection_is_connected(db2) ? "Yes" : "No"); + + printf("\n===== Logger Singleton Demo =====\n"); + Logger* logger1 = get_logger(); + Logger* logger2 = get_logger(); + + printf("Are instances the same? %s\n", (logger1 == logger2) ? "Yes" : "No"); + + logger_log(logger1, "Application started"); + logger_warn(logger1, "Resource usage is high"); + logger_error(logger2, "Failed to connect to service"); + + printf("Log entries: %d\n", logger_get_count(logger2)); + + printf("\n===== User Manager Singleton Demo =====\n"); + UserManager* user_manager1 = get_user_manager(); + UserManager* user_manager2 = get_user_manager(); + + printf("Are instances the same? %s\n", (user_manager1 == user_manager2) ? "Yes" : "No"); + + user_manager_add_user(user_manager1, 1, "Alice", "alice@example.com"); + user_manager_add_user(user_manager1, 2, "Bob", "bob@example.com"); + + printf("User count: %d\n", user_manager_get_count(user_manager2)); + + User* user = user_manager_get_user(user_manager2, 1); + if (user != NULL) { + printf("User #1: %s, %s\n", user->name, user->email); + } + + user_manager_update_user(user_manager2, 1, NULL, NULL, "admin"); + user = user_manager_get_user(user_manager1, 1); + if (user != NULL) { + printf("Updated User #1: %s, %s, %s\n", user->name, user->email, user->role); + } +} + +// Clean up all resources +void cleanup_all() { + config_manager_destroy(); + database_connection_destroy(); + logger_destroy(); + user_manager_destroy(); +} + +int main() { + // Run the demo + demonstrate_singletons(); + cleanup_all(); + return 0; +} diff --git a/snippets/design-patterns/singleton/singleton_pattern.go b/snippets/design-patterns/singleton/singleton_pattern.go new file mode 100644 index 0000000..2c1978b --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.go @@ -0,0 +1,376 @@ +/** + * Singleton Pattern Implementation in Go + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in Go. + */ + +package main + +import ( + "fmt" + "sync" + "time" +) + +// ========== Simple Singleton Implementation ========== + +// Singleton is a simple singleton instance +type Singleton struct { + data map[string]interface{} + createdTime time.Time +} + +var ( + instance *Singleton + once sync.Once +) + +// GetInstance returns the singleton instance +func GetInstance() *Singleton { + once.Do(func() { + instance = &Singleton{ + data: make(map[string]interface{}), + createdTime: time.Now(), + } + fmt.Println("Singleton instance created") + }) + return instance +} + +// SetData sets data in the singleton +func (s *Singleton) SetData(key string, value interface{}) { + s.data[key] = value +} + +// GetData gets data from the singleton +func (s *Singleton) GetData(key string) (interface{}, bool) { + val, exists := s.data[key] + return val, exists +} + +// GetCreationTime returns the time when the singleton was created +func (s *Singleton) GetCreationTime() time.Time { + return s.createdTime +} + +// ========== Thread-Safe Database Connection Singleton ========== + +// DatabaseConnection represents a database connection singleton +type DatabaseConnection struct { + isConnected bool + connectionStr string + connectionCount int + mu sync.Mutex +} + +var ( + dbInstance *DatabaseConnection + dbOnce sync.Once +) + +// GetDatabaseInstance returns the database connection singleton instance +func GetDatabaseInstance() *DatabaseConnection { + dbOnce.Do(func() { + dbInstance = &DatabaseConnection{ + isConnected: false, + connectionStr: "", + connectionCount: 0, + } + fmt.Println("Database connection instance created") + }) + return dbInstance +} + +// Connect connects to the database +func (db *DatabaseConnection) Connect(connectionStr string) bool { + db.mu.Lock() + defer db.mu.Unlock() + + if db.isConnected { + db.connectionCount++ + fmt.Printf("Already connected to database. Connection count: %d\n", db.connectionCount) + return true + } + + // Simulate connection + db.connectionStr = connectionStr + db.isConnected = true + db.connectionCount = 1 + fmt.Printf("Connected to database: %s\n", connectionStr) + return true +} + +// Disconnect disconnects from the database +func (db *DatabaseConnection) Disconnect() bool { + db.mu.Lock() + defer db.mu.Unlock() + + if !db.isConnected { + fmt.Println("Not connected to any database") + return false + } + + db.connectionCount-- + if db.connectionCount == 0 { + db.isConnected = false + fmt.Printf("Disconnected from database: %s\n", db.connectionStr) + } else { + fmt.Printf("Connection count decreased. Remaining connections: %d\n", db.connectionCount) + } + + return true +} + +// IsConnected returns whether the database is connected +func (db *DatabaseConnection) IsConnected() bool { + db.mu.Lock() + defer db.mu.Unlock() + return db.isConnected +} + +// GetConnectionCount returns the number of active connections +func (db *DatabaseConnection) GetConnectionCount() int { + db.mu.Lock() + defer db.mu.Unlock() + return db.connectionCount +} + +// ========== Configuration Manager Singleton ========== + +// ConfigManager represents a configuration manager singleton +type ConfigManager struct { + config map[string]interface{} + mu sync.RWMutex +} + +var ( + configInstance *ConfigManager + configOnce sync.Once +) + +// GetConfigManager returns the configuration manager singleton instance +func GetConfigManager() *ConfigManager { + configOnce.Do(func() { + configInstance = &ConfigManager{ + config: map[string]interface{}{ + "app_name": "Singleton Demo", + "version": "1.0.0", + "debug_mode": false, + "max_retries": 3, + "timeout": 30, + }, + } + fmt.Println("Configuration manager instance created") + }) + return configInstance +} + +// GetConfig returns the entire configuration +func (cm *ConfigManager) GetConfig() map[string]interface{} { + cm.mu.RLock() + defer cm.mu.RUnlock() + + // Return a copy to prevent direct modification + configCopy := make(map[string]interface{}) + for k, v := range cm.config { + configCopy[k] = v + } + return configCopy +} + +// GetValue returns a specific configuration value +func (cm *ConfigManager) GetValue(key string) (interface{}, bool) { + cm.mu.RLock() + defer cm.mu.RUnlock() + + val, exists := cm.config[key] + return val, exists +} + +// SetValue sets a specific configuration value +func (cm *ConfigManager) SetValue(key string, value interface{}) { + cm.mu.Lock() + defer cm.mu.Unlock() + + cm.config[key] = value + fmt.Printf("Configuration updated: %s = %v\n", key, value) +} + +// ========== Logger Singleton ========== + +// LogLevel represents the level of a log message +type LogLevel int + +const ( + DEBUG LogLevel = iota + INFO + WARNING + ERROR +) + +// LogEntry represents a log entry +type LogEntry struct { + Timestamp time.Time + Level LogLevel + Message string +} + +// Logger represents a logger singleton +type Logger struct { + logs []LogEntry + mu sync.Mutex +} + +var ( + loggerInstance *Logger + loggerOnce sync.Once +) + +// GetLogger returns the logger singleton instance +func GetLogger() *Logger { + loggerOnce.Do(func() { + loggerInstance = &Logger{ + logs: make([]LogEntry, 0), + } + fmt.Println("Logger instance created") + }) + return loggerInstance +} + +// Log logs a message with the specified level +func (l *Logger) Log(level LogLevel, message string) { + l.mu.Lock() + defer l.mu.Unlock() + + entry := LogEntry{ + Timestamp: time.Now(), + Level: level, + Message: message, + } + l.logs = append(l.logs, entry) + + // Print to console + levelStr := "UNKNOWN" + switch level { + case DEBUG: + levelStr = "DEBUG" + case INFO: + levelStr = "INFO" + case WARNING: + levelStr = "WARNING" + case ERROR: + levelStr = "ERROR" + } + + fmt.Printf("[%s] %s: %s\n", entry.Timestamp.Format("2006-01-02 15:04:05"), levelStr, message) +} + +// Debug logs a debug message +func (l *Logger) Debug(message string) { + l.Log(DEBUG, message) +} + +// Info logs an info message +func (l *Logger) Info(message string) { + l.Log(INFO, message) +} + +// Warning logs a warning message +func (l *Logger) Warning(message string) { + l.Log(WARNING, message) +} + +// Error logs an error message +func (l *Logger) Error(message string) { + l.Log(ERROR, message) +} + +// GetLogs returns all log entries +func (l *Logger) GetLogs() []LogEntry { + l.mu.Lock() + defer l.mu.Unlock() + + // Return a copy to prevent direct modification + logsCopy := make([]LogEntry, len(l.logs)) + copy(logsCopy, l.logs) + return logsCopy +} + +// ClearLogs clears all log entries +func (l *Logger) ClearLogs() { + l.mu.Lock() + defer l.mu.Unlock() + + l.logs = make([]LogEntry, 0) + fmt.Println("Logs cleared") +} + +// ========== Demo Code ========== + +func demonstrateSingletons() { + fmt.Println("===== Simple Singleton Demo =====") + singleton1 := GetInstance() + singleton2 := GetInstance() + + fmt.Printf("Are instances the same? %v\n", singleton1 == singleton2) + fmt.Printf("Creation time: %v\n", singleton1.GetCreationTime().Format("2006-01-02 15:04:05")) + + singleton1.SetData("name", "Singleton Pattern") + singleton1.SetData("language", "Go") + + name, exists := singleton2.GetData("name") + if exists { + fmt.Printf("Data retrieved from singleton2: name = %v\n", name) + } + + fmt.Println("\n===== Database Connection Singleton Demo =====") + db1 := GetDatabaseInstance() + db2 := GetDatabaseInstance() + + fmt.Printf("Are instances the same? %v\n", db1 == db2) + + db1.Connect("postgres://localhost:5432/mydb") + db2.Connect("postgres://localhost:5432/mydb") + fmt.Printf("Connection count: %d\n", db1.GetConnectionCount()) + + db1.Disconnect() + fmt.Printf("Still connected? %v\n", db2.IsConnected()) + + fmt.Println("\n===== Configuration Manager Demo =====") + config1 := GetConfigManager() + config2 := GetConfigManager() + + fmt.Printf("Are instances the same? %v\n", config1 == config2) + + if val, exists := config1.GetValue("app_name"); exists { + fmt.Printf("Config value: app_name = %v\n", val) + } + + config2.SetValue("debug_mode", true) + if val, exists := config1.GetValue("debug_mode"); exists { + fmt.Printf("Updated config from config1: debug_mode = %v\n", val) + } + + fmt.Println("\n===== Logger Demo =====") + logger1 := GetLogger() + logger2 := GetLogger() + + fmt.Printf("Are instances the same? %v\n", logger1 == logger2) + + logger1.Info("Application started") + logger1.Debug("Initializing components") + logger2.Warning("Resource usage is high") + logger1.Error("Failed to connect to service") + + logs := logger2.GetLogs() + fmt.Printf("Log entries: %d\n", len(logs)) +} + +func main() { + // Run the demo + demonstrateSingletons() +} diff --git a/snippets/design-patterns/singleton/singleton_pattern.js b/snippets/design-patterns/singleton/singleton_pattern.js new file mode 100644 index 0000000..e6e7ab8 --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.js @@ -0,0 +1,396 @@ +/** + * Singleton Pattern Implementation in JavaScript + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in JavaScript. + */ + +// ========== Classic Singleton Implementation ========== + +/** + * Classic Singleton implementation using a class with a static instance property + */ +class ClassicSingleton { + constructor() { + if (ClassicSingleton._instance) { + return ClassicSingleton._instance; + } + + this.timestamp = new Date().getTime(); + this.config = { + apiUrl: 'https://api.example.com', + timeout: 3000, + retries: 3 + }; + + ClassicSingleton._instance = this; + } + + getConfig() { + return this.config; + } + + updateConfig(newConfig) { + this.config = { ...this.config, ...newConfig }; + console.log('Configuration updated:', this.config); + return this.config; + } + + getTimestamp() { + return this.timestamp; + } + + static getInstance() { + if (!ClassicSingleton._instance) { + ClassicSingleton._instance = new ClassicSingleton(); + } + return ClassicSingleton._instance; + } +} + +// Initialize the static property +ClassicSingleton._instance = null; + +// ========== Module Pattern Singleton Implementation ========== + +/** + * Singleton implementation using the Module pattern with an IIFE + * (Immediately Invoked Function Expression) + */ +const DatabaseConnection = (function() { + // Private variables and methods + let instance; + let connectionCount = 0; + + function createConnection() { + // Private methods + function connect() { + connectionCount++; + return `Connected to database (Connection #${connectionCount})`; + } + + function disconnect() { + if (connectionCount > 0) { + connectionCount--; + return `Disconnected from database (Remaining connections: ${connectionCount})`; + } + return 'No active connections to disconnect'; + } + + // Public interface + return { + connect, + disconnect, + getConnectionStatus: () => connectionCount > 0 ? 'Connected' : 'Disconnected', + getConnectionCount: () => connectionCount + }; + } + + return { + // Public method to get the instance + getInstance: function() { + if (!instance) { + instance = createConnection(); + } + return instance; + } + }; +})(); + +// ========== ES6 Module Singleton Implementation ========== + +/** + * Singleton implementation using ES6 module pattern + * In a real application, this would be in its own file and imported where needed + */ +class Logger { + constructor() { + this.logs = []; + } + + log(message) { + const timestamp = new Date().toISOString(); + const logEntry = `${timestamp}: ${message}`; + this.logs.push(logEntry); + console.log(logEntry); + return logEntry; + } + + warn(message) { + return this.log(`WARNING: ${message}`); + } + + error(message) { + return this.log(`ERROR: ${message}`); + } + + getLogs() { + return this.logs; + } + + clearLogs() { + this.logs = []; + return 'Logs cleared'; + } +} + +// Create the singleton instance +const loggerInstance = new Logger(); + +// Export the instance (not the class) +// In a real ES6 module, we would use: +// export default loggerInstance; + +// ========== Lazy Initialization Singleton ========== + +/** + * Singleton with lazy initialization using a closure + */ +const ConfigManager = (function() { + let instance; + + // Private constructor function + function ConfigManagerConstructor() { + let config = { + theme: 'light', + language: 'en', + notifications: true, + autoSave: true + }; + + return { + getConfig: () => ({ ...config }), + setConfig: (newConfig) => { + config = { ...config, ...newConfig }; + return config; + }, + resetConfig: () => { + config = { + theme: 'light', + language: 'en', + notifications: true, + autoSave: true + }; + return config; + } + }; + } + + return { + // This is the public method to get the singleton instance + getInstance: function() { + if (!instance) { + instance = new ConfigManagerConstructor(); + } + return instance; + } + }; +})(); + +// ========== Singleton with Object Literal ========== + +/** + * Simplest singleton implementation using an object literal + * This is a singleton by nature as objects are passed by reference in JavaScript + */ +const AppState = { + user: null, + isLoggedIn: false, + preferences: {}, + + login(userData) { + this.user = userData; + this.isLoggedIn = true; + console.log(`User ${userData.name} logged in`); + }, + + logout() { + const username = this.user ? this.user.name : 'Unknown'; + this.user = null; + this.isLoggedIn = false; + console.log(`User ${username} logged out`); + }, + + updatePreferences(prefs) { + this.preferences = { ...this.preferences, ...prefs }; + console.log('Preferences updated:', this.preferences); + }, + + getState() { + return { + user: this.user, + isLoggedIn: this.isLoggedIn, + preferences: { ...this.preferences } + }; + } +}; + +// ========== Thread-Safe Singleton with Symbol ========== + +/** + * A more advanced singleton implementation using Symbol to make the instance truly private + */ +const UserManager = (function() { + // Using Symbol to create a truly private instance holder + const _instance = Symbol('UserManagerInstance'); + + // Private data store + const _users = Symbol('users'); + + class UserManagerClass { + constructor() { + // Initialize private data + this[_users] = new Map(); + } + + addUser(id, userData) { + if (this[_users].has(id)) { + throw new Error(`User with ID ${id} already exists`); + } + + this[_users].set(id, { + ...userData, + createdAt: new Date() + }); + + return true; + } + + getUser(id) { + if (!this[_users].has(id)) { + return null; + } + + return { ...this[_users].get(id) }; + } + + updateUser(id, userData) { + if (!this[_users].has(id)) { + throw new Error(`User with ID ${id} does not exist`); + } + + const existingUser = this[_users].get(id); + this[_users].set(id, { + ...existingUser, + ...userData, + updatedAt: new Date() + }); + + return true; + } + + deleteUser(id) { + if (!this[_users].has(id)) { + throw new Error(`User with ID ${id} does not exist`); + } + + return this[_users].delete(id); + } + + getAllUsers() { + return Array.from(this[_users].entries()).map(([id, userData]) => ({ + id, + ...userData + })); + } + + getUserCount() { + return this[_users].size; + } + } + + // Create a container for the singleton instance + const SingletonContainer = { + [_instance]: null, + + getInstance() { + if (!this[_instance]) { + this[_instance] = new UserManagerClass(); + } + + return this[_instance]; + } + }; + + return SingletonContainer; +})(); + +// ========== Demo Code ========== + +function demonstrateSingletons() { + console.log('===== Classic Singleton Demo ====='); + const singleton1 = ClassicSingleton.getInstance(); + const singleton2 = ClassicSingleton.getInstance(); + + console.log('Are instances the same?', singleton1 === singleton2); + console.log('Instance timestamp:', singleton1.getTimestamp()); + console.log('Original config:', singleton1.getConfig()); + + singleton2.updateConfig({ timeout: 5000 }); + console.log('Updated config from singleton1:', singleton1.getConfig()); + + console.log('\n===== Database Connection Singleton Demo ====='); + const db1 = DatabaseConnection.getInstance(); + const db2 = DatabaseConnection.getInstance(); + + console.log('Are instances the same?', db1 === db2); + console.log(db1.connect()); + console.log(db1.connect()); + console.log('Connection count:', db2.getConnectionCount()); + console.log(db2.disconnect()); + console.log('Connection status:', db1.getConnectionStatus()); + + console.log('\n===== Logger Singleton Demo ====='); + loggerInstance.log('Application started'); + loggerInstance.warn('Resource usage is high'); + loggerInstance.error('Failed to connect to service'); + console.log('Log entries:', loggerInstance.getLogs().length); + + console.log('\n===== Config Manager Singleton Demo ====='); + const config1 = ConfigManager.getInstance(); + const config2 = ConfigManager.getInstance(); + + console.log('Are instances the same?', config1 === config2); + console.log('Original config:', config1.getConfig()); + + config2.setConfig({ theme: 'dark', autoSave: false }); + console.log('Updated config from config1:', config1.getConfig()); + + console.log('\n===== App State Singleton Demo ====='); + console.log('Initial state:', AppState.getState()); + + AppState.login({ name: 'John Doe', email: 'john@example.com' }); + AppState.updatePreferences({ theme: 'dark', notifications: false }); + console.log('Updated state:', AppState.getState()); + + console.log('\n===== User Manager Singleton Demo ====='); + const userManager1 = UserManager.getInstance(); + const userManager2 = UserManager.getInstance(); + + console.log('Are instances the same?', userManager1 === userManager2); + + userManager1.addUser(1, { name: 'Alice', email: 'alice@example.com' }); + userManager1.addUser(2, { name: 'Bob', email: 'bob@example.com' }); + + console.log('User count:', userManager2.getUserCount()); + console.log('User #1:', userManager2.getUser(1)); + + userManager2.updateUser(1, { role: 'admin' }); + console.log('Updated User #1:', userManager1.getUser(1)); +} + +// Run the demo +demonstrateSingletons(); + +// Export the singleton classes and instances for use in other modules +module.exports = { + ClassicSingleton, + DatabaseConnection, + Logger: loggerInstance, + ConfigManager, + AppState, + UserManager +}; diff --git a/snippets/design-patterns/singleton/singleton_pattern.php b/snippets/design-patterns/singleton/singleton_pattern.php new file mode 100644 index 0000000..bcaf015 --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.php @@ -0,0 +1,388 @@ +timestamp = time(); + $this->config = [ + 'api_url' => 'https://api.example.com', + 'timeout' => 3000, + 'retries' => 3 + ]; + } + + // Prevent cloning of the instance + private function __clone() {} + + // Prevent unserialization of the instance + private function __wakeup() {} + + public static function getInstance() { + if (self::$instance === null) { + self::$instance = new self(); + } + return self::$instance; + } + + public function getConfig() { + return $this->config; + } + + public function updateConfig($key, $value) { + $this->config[$key] = $value; + echo "Configuration updated: {$key} = {$value}\n"; + } + + public function getTimestamp() { + return $this->timestamp; + } +} + +// ========== Database Connection Singleton ========== + +/** + * Singleton implementation for database connection + */ +class DatabaseConnection { + private static $instance = null; + private $isConnected = false; + private $connectionString = ''; + private $connectionCount = 0; + + // Private constructor to prevent direct instantiation + private function __construct() {} + + // Prevent cloning of the instance + private function __clone() {} + + // Prevent unserialization of the instance + private function __wakeup() {} + + public static function getInstance() { + if (self::$instance === null) { + self::$instance = new self(); + } + return self::$instance; + } + + public function connect($connectionString) { + if ($this->isConnected) { + $this->connectionCount++; + echo "Already connected to database. Connection count: {$this->connectionCount}\n"; + return true; + } + + // Simulate connection + $this->connectionString = $connectionString; + $this->isConnected = true; + $this->connectionCount = 1; + echo "Connected to database: {$connectionString}\n"; + return true; + } + + public function disconnect() { + if (!$this->isConnected) { + echo "Not connected to any database.\n"; + return false; + } + + $this->connectionCount--; + if ($this->connectionCount === 0) { + $this->isConnected = false; + echo "Disconnected from database: {$this->connectionString}\n"; + } else { + echo "Connection count decreased. Remaining connections: {$this->connectionCount}\n"; + } + + return true; + } + + public function isConnected() { + return $this->isConnected; + } + + public function getConnectionCount() { + return $this->connectionCount; + } +} + +// ========== Logger Singleton ========== + +/** + * Singleton implementation for logging + */ +class Logger { + private static $instance = null; + private $logs = []; + + // Private constructor to prevent direct instantiation + private function __construct() {} + + // Prevent cloning of the instance + private function __clone() {} + + // Prevent unserialization of the instance + private function __wakeup() {} + + public static function getInstance() { + if (self::$instance === null) { + self::$instance = new self(); + } + return self::$instance; + } + + public function log($message) { + $timestamp = date('Y-m-d H:i:s'); + $logEntry = "{$timestamp}: {$message}"; + $this->logs[] = $logEntry; + echo $logEntry . PHP_EOL; + return $logEntry; + } + + public function warn($message) { + return $this->log("WARNING: {$message}"); + } + + public function error($message) { + return $this->log("ERROR: {$message}"); + } + + public function getLogs() { + return $this->logs; + } + + public function clearLogs() { + $this->logs = []; + echo "Logs cleared" . PHP_EOL; + return 'Logs cleared'; + } +} + +// ========== Configuration Manager Singleton ========== + +/** + * Singleton implementation for configuration management + */ +class ConfigManager { + private static $instance = null; + private $config; + + // Private constructor to prevent direct instantiation + private function __construct() { + $this->config = [ + 'theme' => 'light', + 'language' => 'en', + 'notifications' => true, + 'auto_save' => true + ]; + } + + // Prevent cloning of the instance + private function __clone() {} + + // Prevent unserialization of the instance + private function __wakeup() {} + + public static function getInstance() { + if (self::$instance === null) { + self::$instance = new self(); + } + return self::$instance; + } + + public function getConfig() { + return $this->config; + } + + public function setConfig($key, $value) { + $this->config[$key] = $value; + echo "Configuration updated: {$key} = {$value}" . PHP_EOL; + return $this->config; + } + + public function resetConfig() { + $this->config = [ + 'theme' => 'light', + 'language' => 'en', + 'notifications' => true, + 'auto_save' => true + ]; + echo "Configuration reset to defaults" . PHP_EOL; + return $this->config; + } +} + +// ========== User Manager Singleton ========== + +/** + * Singleton implementation for user management + */ +class UserManager { + private static $instance = null; + private $users = []; + + // Private constructor to prevent direct instantiation + private function __construct() {} + + // Prevent cloning of the instance + private function __clone() {} + + // Prevent unserialization of the instance + private function __wakeup() {} + + public static function getInstance() { + if (self::$instance === null) { + self::$instance = new self(); + } + return self::$instance; + } + + public function addUser($id, $userData) { + if (isset($this->users[$id])) { + throw new Exception("User with ID {$id} already exists"); + } + + $this->users[$id] = array_merge($userData, [ + 'created_at' => date('Y-m-d H:i:s') + ]); + + return true; + } + + public function getUser($id) { + if (!isset($this->users[$id])) { + return null; + } + + return $this->users[$id]; + } + + public function updateUser($id, $userData) { + if (!isset($this->users[$id])) { + throw new Exception("User with ID {$id} does not exist"); + } + + $this->users[$id] = array_merge($this->users[$id], $userData, [ + 'updated_at' => date('Y-m-d H:i:s') + ]); + + return true; + } + + public function deleteUser($id) { + if (!isset($this->users[$id])) { + throw new Exception("User with ID {$id} does not exist"); + } + + unset($this->users[$id]); + return true; + } + + public function getAllUsers() { + $result = []; + foreach ($this->users as $id => $userData) { + $result[] = array_merge(['id' => $id], $userData); + } + return $result; + } + + public function getUserCount() { + return count($this->users); + } +} + +// ========== Demo Code ========== + +function demonstrateSingletons() { + echo "===== Classic Singleton Demo =====" . PHP_EOL; + $singleton1 = ClassicSingleton::getInstance(); + $singleton2 = ClassicSingleton::getInstance(); + + echo "Are instances the same? " . ($singleton1 === $singleton2 ? "Yes" : "No") . PHP_EOL; + echo "Instance timestamp: " . date('Y-m-d H:i:s', $singleton1->getTimestamp()) . PHP_EOL; + + $config = $singleton1->getConfig(); + echo "Original config: api_url = " . $config['api_url'] . PHP_EOL; + + $singleton2->updateConfig('timeout', 5000); + $config = $singleton1->getConfig(); + echo "Updated config from singleton1: timeout = " . $config['timeout'] . PHP_EOL; + + echo PHP_EOL . "===== Database Connection Singleton Demo =====" . PHP_EOL; + $db1 = DatabaseConnection::getInstance(); + $db2 = DatabaseConnection::getInstance(); + + echo "Are instances the same? " . ($db1 === $db2 ? "Yes" : "No") . PHP_EOL; + + $db1->connect("mysql://localhost:3306/mydb"); + $db2->connect("mysql://localhost:3306/mydb"); + echo "Connection count: " . $db1->getConnectionCount() . PHP_EOL; + + $db1->disconnect(); + echo "Still connected? " . ($db2->isConnected() ? "Yes" : "No") . PHP_EOL; + + echo PHP_EOL . "===== Logger Singleton Demo =====" . PHP_EOL; + $logger1 = Logger::getInstance(); + $logger2 = Logger::getInstance(); + + echo "Are instances the same? " . ($logger1 === $logger2 ? "Yes" : "No") . PHP_EOL; + + $logger1->log("Application started"); + $logger1->warn("Resource usage is high"); + $logger2->error("Failed to connect to service"); + + $logs = $logger1->getLogs(); + echo "Log entries: " . count($logs) . PHP_EOL; + + echo PHP_EOL . "===== Config Manager Singleton Demo =====" . PHP_EOL; + $config1 = ConfigManager::getInstance(); + $config2 = ConfigManager::getInstance(); + + echo "Are instances the same? " . ($config1 === $config2 ? "Yes" : "No") . PHP_EOL; + + $configSettings = $config1->getConfig(); + echo "Config value: theme = " . $configSettings['theme'] . PHP_EOL; + + $config2->setConfig('theme', 'dark'); + $configSettings = $config1->getConfig(); + echo "Updated config from config1: theme = " . $configSettings['theme'] . PHP_EOL; + + echo PHP_EOL . "===== User Manager Singleton Demo =====" . PHP_EOL; + $userManager1 = UserManager::getInstance(); + $userManager2 = UserManager::getInstance(); + + echo "Are instances the same? " . ($userManager1 === $userManager2 ? "Yes" : "No") . PHP_EOL; + + $userManager1->addUser(1, ['name' => 'Alice', 'email' => 'alice@example.com']); + $userManager1->addUser(2, ['name' => 'Bob', 'email' => 'bob@example.com']); + + echo "User count: " . $userManager2->getUserCount() . PHP_EOL; + + $user = $userManager2->getUser(1); + echo "User #1: " . $user['name'] . ", " . $user['email'] . PHP_EOL; + + $userManager2->updateUser(1, ['role' => 'admin']); + $user = $userManager1->getUser(1); + echo "Updated User #1: " . $user['name'] . ", " . $user['email'] . ", " . $user['role'] . PHP_EOL; +} + +// Run the demo +demonstrateSingletons(); diff --git a/snippets/design-patterns/singleton/singleton_pattern.py b/snippets/design-patterns/singleton/singleton_pattern.py new file mode 100644 index 0000000..daee333 --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.py @@ -0,0 +1,255 @@ +#!/usr/bin/env python3 +""" +Singleton Pattern Implementation in Python + +This demonstrates various implementations of the Singleton pattern in Python. +""" + + +# Method 1: Classic Implementation (Not Thread-Safe) +class ClassicSingleton: + """ + Classic implementation of the Singleton pattern. + Not thread-safe, but simple and effective for single-threaded applications. + """ + _instance = None + + def __new__(cls): + if cls._instance is None: + print("Creating new instance of ClassicSingleton") + cls._instance = super(ClassicSingleton, cls).__new__(cls) + cls._instance.initialize() + return cls._instance + + def initialize(self): + """Initialize the singleton instance""" + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# Method 2: Decorator-based implementation +def singleton(cls): + """ + Singleton decorator. + Makes any class a Singleton by replacing its __new__ method. + """ + instances = {} + + def get_instance(*args, **kwargs): + if cls not in instances: + print(f"Creating new instance of {cls.__name__} via decorator") + instances[cls] = cls(*args, **kwargs) + return instances[cls] + + return get_instance + + +@singleton +class DecoratedSingleton: + """Singleton class implemented using a decorator""" + + def __init__(self): + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# Method 3: Metaclass-based implementation +class SingletonMeta(type): + """ + Metaclass for implementing the Singleton pattern. + More advanced and flexible than other implementations. + """ + _instances = {} + + def __call__(cls, *args, **kwargs): + if cls not in cls._instances: + print(f"Creating new instance of {cls.__name__} via metaclass") + cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs) + return cls._instances[cls] + + +class MetaclassSingleton(metaclass=SingletonMeta): + """Singleton class implemented using a metaclass""" + + def __init__(self): + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# Method 4: Module-level Singleton +# This approach leverages Python's module import system to create singletons +# Since modules are imported only once, objects defined at module level are singletons + +class _ModuleSingleton: + """ + Private class for module-level singleton. + The actual instance is exposed as a module-level variable. + """ + def __init__(self): + print("Creating module-level Singleton") + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# The single instance that will be imported elsewhere +module_singleton = _ModuleSingleton() + + +# Method 5: Borg pattern (Monostate) +# All instances share state, but are not the same object +class BorgSingleton: + """ + Implementation of the Borg pattern. + All instances share state but are not the same object. + """ + _shared_state = {} + + def __init__(self): + # Share the __dict__ (state) among all instances + self.__dict__ = self._shared_state + if not self._shared_state: + print("Initializing Borg Singleton shared state") + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# Method 6: Thread-safe Singleton with double-checked locking +import threading + +class ThreadSafeSingleton: + """ + Thread-safe implementation of the Singleton pattern. + Uses a lock to prevent race conditions. + """ + _instance = None + _lock = threading.Lock() + + def __new__(cls): + # Double-checked locking pattern + if cls._instance is None: + with cls._lock: + if cls._instance is None: # Check again after acquiring the lock + print("Creating thread-safe Singleton instance") + cls._instance = super(ThreadSafeSingleton, cls).__new__(cls) + cls._instance.initialize() + return cls._instance + + def initialize(self): + """Initialize the singleton instance""" + self.value = 0 + + def increment(self): + """Increment the value and return it""" + self.value += 1 + return self.value + + +# Example usage +def demonstrate_classic_singleton(): + """Demonstrate classic singleton pattern""" + print("\n=== Classic Singleton ===") + s1 = ClassicSingleton() + s2 = ClassicSingleton() + + print(f"s1 is s2: {s1 is s2}") + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def demonstrate_decorated_singleton(): + """Demonstrate decorator-based singleton pattern""" + print("\n=== Decorated Singleton ===") + s1 = DecoratedSingleton() + s2 = DecoratedSingleton() + + print(f"s1 is s2: {s1 is s2}") + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def demonstrate_metaclass_singleton(): + """Demonstrate metaclass-based singleton pattern""" + print("\n=== Metaclass Singleton ===") + s1 = MetaclassSingleton() + s2 = MetaclassSingleton() + + print(f"s1 is s2: {s1 is s2}") + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def demonstrate_module_singleton(): + """Demonstrate module-level singleton pattern""" + print("\n=== Module Singleton ===") + # We would normally import this, but here we use the one defined above + s1 = module_singleton + s2 = module_singleton + + print(f"s1 is s2: {s1 is s2}") + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def demonstrate_borg_singleton(): + """Demonstrate Borg pattern (monostate)""" + print("\n=== Borg Singleton (Monostate) ===") + s1 = BorgSingleton() + s2 = BorgSingleton() + + print(f"s1 is s2: {s1 is s2}") # Will be False! + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def demonstrate_thread_safe_singleton(): + """Demonstrate thread-safe singleton pattern""" + print("\n=== Thread-Safe Singleton ===") + s1 = ThreadSafeSingleton() + s2 = ThreadSafeSingleton() + + print(f"s1 is s2: {s1 is s2}") + print(f"s1.increment(): {s1.increment()}") + print(f"s2.increment(): {s2.increment()}") + print(f"s1.value: {s1.value}, s2.value: {s2.value}") + + +def main(): + """Run demonstrations of all singleton implementations""" + print("Singleton Pattern Demonstrations") + print("===============================") + + demonstrate_classic_singleton() + demonstrate_decorated_singleton() + demonstrate_metaclass_singleton() + demonstrate_module_singleton() + demonstrate_borg_singleton() + demonstrate_thread_safe_singleton() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/snippets/design-patterns/singleton/singleton_pattern.rb b/snippets/design-patterns/singleton/singleton_pattern.rb new file mode 100644 index 0000000..282c414 --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.rb @@ -0,0 +1,364 @@ +#!/usr/bin/env ruby + +# Singleton Pattern Implementation in Ruby +# +# The Singleton Pattern is a creational design pattern that ensures a class has only one instance +# and provides a global point of access to it. This is useful when exactly one object is needed +# to coordinate actions across the system. +# +# This file demonstrates several ways to implement the Singleton pattern in Ruby. + +require 'singleton' +require 'time' + +# ========== Classic Singleton Implementation ========== + +# Classic Singleton implementation using Ruby's built-in Singleton module +class ClassicSingleton + include Singleton + + attr_reader :timestamp + + def initialize + @timestamp = Time.now + @config = { + 'api_url' => 'https://api.example.com', + 'timeout' => 3000, + 'retries' => 3 + } + end + + def get_config + @config.clone + end + + def update_config(key, value) + @config[key] = value + puts "Configuration updated: #{key} = #{value}" + end +end + +# ========== Thread-Safe Singleton Implementation ========== + +# Thread-safe Singleton implementation using a mutex for synchronization +class ThreadSafeSingleton + # Class variable to store the singleton instance + @@instance = nil + @@mutex = Mutex.new + + # Private class method to create the instance + def self.instance + return @@instance if @@instance + + @@mutex.synchronize do + # Check again in case another thread created the instance while we were waiting + @@instance ||= new + end + + @@instance + end + + # Make new and clone private to prevent creating new instances + private_class_method :new + private :clone + + attr_reader :connection_count, :connected + alias_method :connected?, :connected + + def initialize + @connection_count = 0 + @connected = false + @connection_string = '' + end + + def connect(connection_string) + if @connected + @connection_count += 1 + puts "Already connected to database. Connection count: #{@connection_count}" + return true + end + + # Simulate connection + @connection_string = connection_string + @connected = true + @connection_count = 1 + puts "Connected to database: #{connection_string}" + true + end + + def disconnect + unless @connected + puts "Not connected to any database." + return false + end + + @connection_count -= 1 + if @connection_count == 0 + @connected = false + puts "Disconnected from database: #{@connection_string}" + else + puts "Connection count decreased. Remaining connections: #{@connection_count}" + end + + true + end +end + +# ========== Logger Singleton ========== + +# Logger Singleton implementation +class Logger + # Class variable to store the singleton instance + @@instance = nil + + # Class method to access the singleton instance + def self.instance + @@instance ||= new + end + + # Make new private to prevent creating new instances + private_class_method :new + + def initialize + @logs = [] + end + + def log(message) + timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S") + log_entry = "#{timestamp}: #{message}" + @logs << log_entry + puts log_entry + log_entry + end + + def warn(message) + log("WARNING: #{message}") + end + + def error(message) + log("ERROR: #{message}") + end + + def get_logs + @logs.clone + end + + def clear_logs + @logs = [] + puts "Logs cleared" + "Logs cleared" + end +end + +# ========== Configuration Manager Singleton ========== + +# Configuration Manager Singleton implementation +class ConfigManager + # Class variable to store the singleton instance + @@instance = nil + + # Class method to access the singleton instance + def self.instance + @@instance ||= new + end + + # Make new private to prevent creating new instances + private_class_method :new + + def initialize + @config = { + 'theme' => 'light', + 'language' => 'en', + 'notifications' => true, + 'auto_save' => true + } + end + + def get_config + @config.clone + end + + def set_config(key, value) + @config[key] = value + puts "Configuration updated: #{key} = #{value}" + @config + end + + def reset_config + @config = { + 'theme' => 'light', + 'language' => 'en', + 'notifications' => true, + 'auto_save' => true + } + puts "Configuration reset to defaults" + @config + end +end + +# ========== User Manager Singleton ========== + +# User Manager Singleton implementation +class UserManager + # Class variable to store the singleton instance + @@instance = nil + @@mutex = Mutex.new + + # Class method to access the singleton instance + def self.instance + return @@instance if @@instance + + @@mutex.synchronize do + @@instance ||= new + end + + @@instance + end + + # Make new private to prevent creating new instances + private_class_method :new + + def initialize + @users = {} + end + + def add_user(id, user_data) + @@mutex.synchronize do + if @users.key?(id) + raise "User with ID #{id} already exists" + end + + @users[id] = user_data.merge({ + 'created_at' => Time.now + }) + + true + end + end + + def get_user(id) + @@mutex.synchronize do + return nil unless @users.key?(id) + @users[id].clone + end + end + + def update_user(id, user_data) + @@mutex.synchronize do + unless @users.key?(id) + raise "User with ID #{id} does not exist" + end + + @users[id] = @users[id].merge(user_data).merge({ + 'updated_at' => Time.now + }) + + true + end + end + + def delete_user(id) + @@mutex.synchronize do + unless @users.key?(id) + raise "User with ID #{id} does not exist" + end + + @users.delete(id) + true + end + end + + def get_all_users + @@mutex.synchronize do + result = [] + @users.each do |id, user_data| + result << { 'id' => id }.merge(user_data) + end + result + end + end + + def user_count + @@mutex.synchronize do + @users.size + end + end +end + +# ========== Demo Code ========== + +def demonstrate_singletons + puts "===== Classic Singleton Demo =====" + singleton1 = ClassicSingleton.instance + singleton2 = ClassicSingleton.instance + + puts "Are instances the same? #{singleton1.equal?(singleton2) ? 'Yes' : 'No'}" + puts "Instance timestamp: #{singleton1.timestamp}" + + config = singleton1.get_config + puts "Original config: api_url = #{config['api_url']}" + + singleton2.update_config('timeout', 5000) + config = singleton1.get_config + puts "Updated config from singleton1: timeout = #{config['timeout']}" + + puts "\n===== Thread-Safe Singleton Demo =====" + db1 = ThreadSafeSingleton.instance + db2 = ThreadSafeSingleton.instance + + puts "Are instances the same? #{db1.equal?(db2) ? 'Yes' : 'No'}" + + db1.connect("mysql://localhost:3306/mydb") + db2.connect("mysql://localhost:3306/mydb") + puts "Connection count: #{db1.connection_count}" + + db1.disconnect + puts "Still connected? #{db2.connected? ? 'Yes' : 'No'}" + + puts "\n===== Logger Singleton Demo =====" + logger1 = Logger.instance + logger2 = Logger.instance + + puts "Are instances the same? #{logger1.equal?(logger2) ? 'Yes' : 'No'}" + + logger1.log("Application started") + logger1.warn("Resource usage is high") + logger2.error("Failed to connect to service") + + logs = logger2.get_logs + puts "Log entries: #{logs.size}" + + puts "\n===== Config Manager Singleton Demo =====" + config1 = ConfigManager.instance + config2 = ConfigManager.instance + + puts "Are instances the same? #{config1.equal?(config2) ? 'Yes' : 'No'}" + + config_settings = config1.get_config + puts "Config value: theme = #{config_settings['theme']}" + + config2.set_config('theme', 'dark') + config_settings = config1.get_config + puts "Updated config from config1: theme = #{config_settings['theme']}" + + puts "\n===== User Manager Singleton Demo =====" + user_manager1 = UserManager.instance + user_manager2 = UserManager.instance + + puts "Are instances the same? #{user_manager1.equal?(user_manager2) ? 'Yes' : 'No'}" + + user_manager1.add_user(1, { 'name' => 'Alice', 'email' => 'alice@example.com' }) + user_manager1.add_user(2, { 'name' => 'Bob', 'email' => 'bob@example.com' }) + + puts "User count: #{user_manager2.user_count}" + + user = user_manager2.get_user(1) + puts "User #1: #{user['name']}, #{user['email']}" + + user_manager2.update_user(1, { 'role' => 'admin' }) + user = user_manager1.get_user(1) + puts "Updated User #1: #{user['name']}, #{user['email']}, #{user['role']}" +end + +# Run the demo +demonstrate_singletons diff --git a/snippets/design-patterns/singleton/singleton_pattern.rs b/snippets/design-patterns/singleton/singleton_pattern.rs new file mode 100644 index 0000000..44ba206 --- /dev/null +++ b/snippets/design-patterns/singleton/singleton_pattern.rs @@ -0,0 +1,466 @@ +/** + * Singleton Pattern Implementation in Rust + * + * The Singleton Pattern is a creational design pattern that ensures a class has only one instance + * and provides a global point of access to it. This is useful when exactly one object is needed + * to coordinate actions across the system. + * + * This file demonstrates several ways to implement the Singleton pattern in Rust. + */ + +use std::collections::HashMap; +use std::sync::{Arc, Mutex, Once}; +use std::time::{SystemTime, UNIX_EPOCH}; +use std::fmt; + +// ========== Lazy Static Singleton Implementation ========== + +// Lazy static is a common way to implement singletons in Rust +// This requires the lazy_static crate +#[cfg(feature = "lazy_static")] +mod lazy_static_singleton { + use super::*; + use lazy_static::lazy_static; + + #[derive(Debug)] + pub struct ClassicSingleton { + timestamp: SystemTime, + config: Mutex>, + } + + impl ClassicSingleton { + fn new() -> Self { + let mut config = HashMap::new(); + config.insert("api_url".to_string(), "https://api.example.com".to_string()); + config.insert("timeout".to_string(), "3000".to_string()); + config.insert("retries".to_string(), "3".to_string()); + + ClassicSingleton { + timestamp: SystemTime::now(), + config: Mutex::new(config), + } + } + + pub fn get_config(&self) -> HashMap { + let config = self.config.lock().unwrap(); + config.clone() + } + + pub fn update_config(&self, key: &str, value: &str) { + let mut config = self.config.lock().unwrap(); + config.insert(key.to_string(), value.to_string()); + println!("Configuration updated: {} = {}", key, value); + } + + pub fn get_timestamp(&self) -> SystemTime { + self.timestamp + } + } + + lazy_static! { + pub static ref INSTANCE: ClassicSingleton = ClassicSingleton::new(); + } +} + +// ========== Once Cell Singleton Implementation ========== + +// Once Cell is a more modern approach in Rust's standard library +mod once_cell_singleton { + use super::*; + use std::sync::OnceLock; + + #[derive(Debug)] + pub struct DatabaseConnection { + connection_count: Mutex, + is_connected: Mutex, + connection_string: Mutex, + } + + impl DatabaseConnection { + fn new() -> Self { + DatabaseConnection { + connection_count: Mutex::new(0), + is_connected: Mutex::new(false), + connection_string: Mutex::new(String::new()), + } + } + + pub fn connect(&self, connection_string: &str) -> bool { + let mut is_connected = self.is_connected.lock().unwrap(); + let mut count = self.connection_count.lock().unwrap(); + let mut conn_str = self.connection_string.lock().unwrap(); + + if *is_connected { + *count += 1; + println!("Already connected to database. Connection count: {}", *count); + return true; + } + + // Simulate connection + *conn_str = connection_string.to_string(); + *is_connected = true; + *count = 1; + println!("Connected to database: {}", connection_string); + true + } + + pub fn disconnect(&self) -> bool { + let mut is_connected = self.is_connected.lock().unwrap(); + let mut count = self.connection_count.lock().unwrap(); + let conn_str = self.connection_string.lock().unwrap(); + + if !*is_connected { + println!("Not connected to any database."); + return false; + } + + *count -= 1; + if *count == 0 { + *is_connected = false; + println!("Disconnected from database: {}", *conn_str); + } else { + println!("Connection count decreased. Remaining connections: {}", *count); + } + + true + } + + pub fn is_connected(&self) -> bool { + let is_connected = self.is_connected.lock().unwrap(); + *is_connected + } + + pub fn connection_count(&self) -> i32 { + let count = self.connection_count.lock().unwrap(); + *count + } + } + + pub fn instance() -> &'static DatabaseConnection { + static INSTANCE: OnceLock = OnceLock::new(); + INSTANCE.get_or_init(|| DatabaseConnection::new()) + } +} + +// ========== Thread-Safe Singleton with Once ========== + +// Traditional thread-safe singleton using Once +mod thread_safe_singleton { + use super::*; + + pub struct Logger { + logs: Mutex>, + } + + impl Logger { + fn new() -> Self { + Logger { + logs: Mutex::new(Vec::new()), + } + } + + pub fn log(&self, message: &str) -> String { + let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string(); + let log_entry = format!("{}: {}", timestamp, message); + + let mut logs = self.logs.lock().unwrap(); + logs.push(log_entry.clone()); + println!("{}", log_entry); + + log_entry + } + + pub fn warn(&self, message: &str) -> String { + self.log(&format!("WARNING: {}", message)) + } + + pub fn error(&self, message: &str) -> String { + self.log(&format!("ERROR: {}", message)) + } + + pub fn get_logs(&self) -> Vec { + let logs = self.logs.lock().unwrap(); + logs.clone() + } + + pub fn clear_logs(&self) -> &str { + let mut logs = self.logs.lock().unwrap(); + logs.clear(); + println!("Logs cleared"); + "Logs cleared" + } + } + + // Static instance with Once initialization + pub fn get_instance() -> &'static Logger { + static mut INSTANCE: Option = None; + static ONCE: Once = Once::new(); + + unsafe { + ONCE.call_once(|| { + INSTANCE = Some(Logger::new()); + }); + + INSTANCE.as_ref().unwrap() + } + } +} + +// ========== Arc-Mutex Singleton Implementation ========== + +// A more idiomatic Rust approach using Arc and Mutex +mod arc_mutex_singleton { + use super::*; + + #[derive(Debug, Clone)] + pub struct ConfigManager { + config: Arc>>, + } + + impl ConfigManager { + fn new() -> Self { + let mut config = HashMap::new(); + config.insert("theme".to_string(), "light".to_string()); + config.insert("language".to_string(), "en".to_string()); + config.insert("notifications".to_string(), "true".to_string()); + config.insert("auto_save".to_string(), "true".to_string()); + + ConfigManager { + config: Arc::new(Mutex::new(config)), + } + } + + pub fn get_config(&self) -> HashMap { + let config = self.config.lock().unwrap(); + config.clone() + } + + pub fn set_config(&self, key: &str, value: &str) -> HashMap { + let mut config = self.config.lock().unwrap(); + config.insert(key.to_string(), value.to_string()); + println!("Configuration updated: {} = {}", key, value); + config.clone() + } + + pub fn reset_config(&self) -> HashMap { + let mut config = self.config.lock().unwrap(); + config.clear(); + config.insert("theme".to_string(), "light".to_string()); + config.insert("language".to_string(), "en".to_string()); + config.insert("notifications".to_string(), "true".to_string()); + config.insert("auto_save".to_string(), "true".to_string()); + println!("Configuration reset to defaults"); + config.clone() + } + } + + // Singleton instance using lazy_static or once_cell + use std::sync::OnceLock; + + pub fn instance() -> &'static ConfigManager { + static INSTANCE: OnceLock = OnceLock::new(); + INSTANCE.get_or_init(|| ConfigManager::new()) + } +} + +// ========== User Manager Singleton ========== + +// User Manager Singleton implementation +mod user_manager_singleton { + use super::*; + use std::collections::HashMap; + use chrono::{DateTime, Local}; + + #[derive(Debug, Clone)] + pub struct UserData { + pub name: String, + pub email: String, + pub role: Option, + pub created_at: DateTime, + pub updated_at: Option>, + } + + impl fmt::Display for UserData { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "User {{ name: {}, email: {}, role: {:?} }}", + self.name, self.email, self.role) + } + } + + #[derive(Debug)] + pub struct UserManager { + users: Mutex>, + } + + impl UserManager { + fn new() -> Self { + UserManager { + users: Mutex::new(HashMap::new()), + } + } + + pub fn add_user(&self, id: i32, name: &str, email: &str) -> Result<(), String> { + let mut users = self.users.lock().unwrap(); + + if users.contains_key(&id) { + return Err(format!("User with ID {} already exists", id)); + } + + users.insert(id, UserData { + name: name.to_string(), + email: email.to_string(), + role: None, + created_at: Local::now(), + updated_at: None, + }); + + Ok(()) + } + + pub fn get_user(&self, id: i32) -> Option { + let users = self.users.lock().unwrap(); + users.get(&id).cloned() + } + + pub fn update_user(&self, id: i32, name: Option<&str>, email: Option<&str>, role: Option<&str>) -> Result<(), String> { + let mut users = self.users.lock().unwrap(); + + if !users.contains_key(&id) { + return Err(format!("User with ID {} does not exist", id)); + } + + let user = users.get_mut(&id).unwrap(); + + if let Some(name_val) = name { + user.name = name_val.to_string(); + } + + if let Some(email_val) = email { + user.email = email_val.to_string(); + } + + if let Some(role_val) = role { + user.role = Some(role_val.to_string()); + } + + user.updated_at = Some(Local::now()); + + Ok(()) + } + + pub fn delete_user(&self, id: i32) -> Result<(), String> { + let mut users = self.users.lock().unwrap(); + + if !users.contains_key(&id) { + return Err(format!("User with ID {} does not exist", id)); + } + + users.remove(&id); + Ok(()) + } + + pub fn get_all_users(&self) -> Vec<(i32, UserData)> { + let users = self.users.lock().unwrap(); + users.iter().map(|(&id, user)| (id, user.clone())).collect() + } + + pub fn user_count(&self) -> usize { + let users = self.users.lock().unwrap(); + users.len() + } + } + + // Singleton instance using OnceLock + use std::sync::OnceLock; + + pub fn instance() -> &'static UserManager { + static INSTANCE: OnceLock = OnceLock::new(); + INSTANCE.get_or_init(|| UserManager::new()) + } +} + +// ========== Demo Code ========== + +fn demonstrate_singletons() { + // Note: In a real application, you'd need to add the lazy_static crate + // to your Cargo.toml and uncomment this section + /* + println!("===== Classic Singleton Demo ====="); + let singleton1 = &lazy_static_singleton::INSTANCE; + let singleton2 = &lazy_static_singleton::INSTANCE; + + println!("Are instances the same? {}", std::ptr::eq(singleton1, singleton2)); + println!("Instance timestamp: {:?}", singleton1.get_timestamp()); + + let config = singleton1.get_config(); + println!("Original config: api_url = {}", config.get("api_url").unwrap()); + + singleton2.update_config("timeout", "5000"); + let config = singleton1.get_config(); + println!("Updated config from singleton1: timeout = {}", config.get("timeout").unwrap()); + */ + + println!("\n===== Once Cell Singleton Demo ====="); + let db1 = once_cell_singleton::instance(); + let db2 = once_cell_singleton::instance(); + + println!("Are instances the same? {}", std::ptr::eq(db1, db2)); + + db1.connect("mysql://localhost:3306/mydb"); + db2.connect("mysql://localhost:3306/mydb"); + println!("Connection count: {}", db1.connection_count()); + + db1.disconnect(); + println!("Still connected? {}", db2.is_connected()); + + println!("\n===== Thread-Safe Singleton Demo ====="); + let logger1 = thread_safe_singleton::get_instance(); + let logger2 = thread_safe_singleton::get_instance(); + + println!("Are instances the same? {}", std::ptr::eq(logger1, logger2)); + + logger1.log("Application started"); + logger1.warn("Resource usage is high"); + logger2.error("Failed to connect to service"); + + let logs = logger2.get_logs(); + println!("Log entries: {}", logs.len()); + + println!("\n===== Arc-Mutex Singleton Demo ====="); + let config1 = arc_mutex_singleton::instance(); + let config2 = arc_mutex_singleton::instance(); + + println!("Are instances the same? {}", std::ptr::eq(config1, config2)); + + let config_settings = config1.get_config(); + println!("Config value: theme = {}", config_settings.get("theme").unwrap()); + + config2.set_config("theme", "dark"); + let config_settings = config1.get_config(); + println!("Updated config from config1: theme = {}", config_settings.get("theme").unwrap()); + + println!("\n===== User Manager Singleton Demo ====="); + let user_manager1 = user_manager_singleton::instance(); + let user_manager2 = user_manager_singleton::instance(); + + println!("Are instances the same? {}", std::ptr::eq(user_manager1, user_manager2)); + + user_manager1.add_user(1, "Alice", "alice@example.com").unwrap(); + user_manager1.add_user(2, "Bob", "bob@example.com").unwrap(); + + println!("User count: {}", user_manager2.user_count()); + + if let Some(user) = user_manager2.get_user(1) { + println!("User #1: {}, {}", user.name, user.email); + } + + user_manager2.update_user(1, None, None, Some("admin")).unwrap(); + if let Some(user) = user_manager1.get_user(1) { + println!("Updated User #1: {}, {}, {:?}", user.name, user.email, user.role); + } +} + +fn main() { + // Run the demo + demonstrate_singletons(); +} diff --git a/snippets/devops/ci_cd_pipeline.sh b/snippets/devops/ci_cd_pipeline.sh new file mode 100644 index 0000000..af80d42 --- /dev/null +++ b/snippets/devops/ci_cd_pipeline.sh @@ -0,0 +1,97 @@ +#!/bin/bash +# +# Simple CI/CD Pipeline Script +# This script demonstrates a basic CI/CD pipeline for a Node.js application +# + +# Exit immediately if a command exits with a non-zero status +set -e + +# Print commands and their arguments as they are executed +set -x + +# Define variables +APP_NAME="my-nodejs-app" +REPO_URL="https://github.com/username/my-nodejs-app.git" +DEPLOY_DIR="/var/www/my-nodejs-app" +LOG_FILE="pipeline.log" + +# Function to log messages +log_message() { + local timestamp=$(date +"%Y-%m-%d %H:%M:%S") + echo "[$timestamp] $1" | tee -a $LOG_FILE +} + +# Function to handle errors +handle_error() { + log_message "ERROR: An error occurred on line $1" + exit 1 +} + +# Set up error handling +trap 'handle_error $LINENO' ERR + +# Start the pipeline +log_message "Starting CI/CD pipeline for $APP_NAME" + +# Step 1: Clean workspace +log_message "Step 1: Cleaning workspace" +rm -rf build +mkdir -p build +cd build + +# Step 2: Clone the repository +log_message "Step 2: Cloning repository" +git clone $REPO_URL . +git checkout main + +# Step 3: Install dependencies +log_message "Step 3: Installing dependencies" +npm ci + +# Step 4: Run linting +log_message "Step 4: Running linting" +npm run lint + +# Step 5: Run tests +log_message "Step 5: Running tests" +npm test + +# Step 6: Build the application +log_message "Step 6: Building the application" +npm run build + +# Step 7: Run security audit +log_message "Step 7: Running security audit" +npm audit --production + +# Step 8: Deploy to production +log_message "Step 8: Deploying to production" +# Check if deploy directory exists +if [ ! -d "$DEPLOY_DIR" ]; then + mkdir -p $DEPLOY_DIR +fi + +# Copy build files to deploy directory +cp -r dist/* $DEPLOY_DIR + +# Step 9: Restart the application +log_message "Step 9: Restarting the application" +# This is a simplified example - in reality, you might use systemd, PM2, etc. +cd $DEPLOY_DIR +npm run stop || true # Don't fail if the app isn't running +npm run start + +# Step 10: Run smoke tests +log_message "Step 10: Running smoke tests" +# Simple curl test to verify the application is responding +sleep 5 # Wait for the app to start +if curl -s http://localhost:3000/health | grep -q "ok"; then + log_message "Smoke test passed!" +else + log_message "Smoke test failed!" + exit 1 +fi + +# Pipeline completed successfully +log_message "CI/CD pipeline completed successfully!" diff --git a/snippets/linux/system_monitor.sh b/snippets/linux/system_monitor.sh new file mode 100644 index 0000000..ca584e9 --- /dev/null +++ b/snippets/linux/system_monitor.sh @@ -0,0 +1,204 @@ +#!/bin/bash +# +# System Monitoring Script +# This script collects and displays system information +# + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[0;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Function to print section headers +print_header() { + echo -e "\n${BLUE}==== $1 ====${NC}" +} + +# Function to print success/warning/error messages +print_status() { + if [ "$2" == "ok" ]; then + echo -e "${GREEN}$1${NC}" + elif [ "$2" == "warning" ]; then + echo -e "${YELLOW}$1${NC}" + else + echo -e "${RED}$1${NC}" + fi +} + +# Check if script is run as root +if [ "$EUID" -ne 0 ]; then + print_status "Warning: This script should be run as root for full functionality" "warning" +fi + +# System Information +print_header "System Information" +echo "Hostname: $(hostname)" +echo "Kernel: $(uname -r)" +echo "Uptime: $(uptime -p)" +echo "Last Boot: $(who -b | awk '{print $3, $4}')" + +# CPU Information +print_header "CPU Information" +cpu_model=$(grep "model name" /proc/cpuinfo | head -n 1 | cut -d ':' -f 2 | sed 's/^[ \t]*//') +cpu_cores=$(grep -c "processor" /proc/cpuinfo) +cpu_load=$(uptime | awk -F'load average:' '{ print $2 }' | cut -d, -f1 | sed 's/^[ \t]*//') + +echo "CPU Model: $cpu_model" +echo "CPU Cores: $cpu_cores" +echo -n "CPU Load: $cpu_load " + +# Check CPU load +cpu_load_float=$(echo $cpu_load | sed 's/,/./g') +if (( $(echo "$cpu_load_float < 1" | bc -l) )); then + print_status "(Normal)" "ok" +elif (( $(echo "$cpu_load_float < 2" | bc -l) )); then + print_status "(Moderate)" "warning" +else + print_status "(High)" "error" +fi + +# Memory Information +print_header "Memory Information" +total_mem=$(free -h | grep "Mem:" | awk '{print $2}') +used_mem=$(free -h | grep "Mem:" | awk '{print $3}') +free_mem=$(free -h | grep "Mem:" | awk '{print $4}') +mem_usage_percent=$(free | grep Mem | awk '{print $3/$2 * 100.0}' | cut -d. -f1) + +echo "Total Memory: $total_mem" +echo "Used Memory: $used_mem" +echo "Free Memory: $free_mem" +echo -n "Memory Usage: $mem_usage_percent% " + +# Check memory usage +if [ "$mem_usage_percent" -lt 70 ]; then + print_status "(Normal)" "ok" +elif [ "$mem_usage_percent" -lt 85 ]; then + print_status "(Moderate)" "warning" +else + print_status "(High)" "error" +fi + +# Disk Usage +print_header "Disk Usage" +echo "Filesystem Size Used Avail Use% Mounted on" +df -h | grep -v "tmpfs" | grep -v "udev" | grep -v "loop" | tail -n +2 | while read line; do + usage_percent=$(echo $line | awk '{print $5}' | sed 's/%//') + if [ "$usage_percent" -lt 70 ]; then + status="ok" + elif [ "$usage_percent" -lt 85 ]; then + status="warning" + else + status="error" + fi + + filesystem=$(echo $line | awk '{print $1}') + size=$(echo $line | awk '{print $2}') + used=$(echo $line | awk '{print $3}') + avail=$(echo $line | awk '{print $4}') + use_percent=$(echo $line | awk '{print $5}') + mounted=$(echo $line | awk '{print $6}') + + printf "%-15s %-5s %-5s %-6s " "$filesystem" "$size" "$used" "$avail" + print_status "$use_percent" "$status" + echo " $mounted" +done + +# Network Information +print_header "Network Information" +echo "Interface IP Address MAC Address Status" +ip -o addr show | grep 'inet ' | grep -v '127.0.0.1' | while read line; do + interface=$(echo $line | awk '{print $2}') + ip_address=$(echo $line | awk '{print $4}') + mac_address=$(ip link show $interface | grep link/ether | awk '{print $2}') + status=$(ip link show $interface | grep -o "state [A-Z]*" | cut -d ' ' -f 2) + + printf "%-12s %-18s %-18s " "$interface" "$ip_address" "$mac_address" + if [ "$status" == "UP" ]; then + print_status "$status" "ok" + else + print_status "$status" "error" + fi +done + +# Process Information +print_header "Top 5 CPU-Consuming Processes" +ps aux --sort=-%cpu | head -6 + +print_header "Top 5 Memory-Consuming Processes" +ps aux --sort=-%mem | head -6 + +# System Load +print_header "System Load Average (1, 5, 15 min)" +load_avg=$(cat /proc/loadavg | awk '{print $1, $2, $3}') +echo $load_avg + +# Check for failed services +print_header "Failed Services" +if command -v systemctl &> /dev/null; then + failed_services=$(systemctl --failed | grep "failed" | wc -l) + if [ "$failed_services" -eq 0 ]; then + print_status "No failed services found" "ok" + else + print_status "$failed_services failed services found:" "error" + systemctl --failed | grep "failed" + fi +else + echo "systemctl not found, skipping service check" +fi + +# Check for system updates +print_header "System Updates" +if command -v apt &> /dev/null; then + # Debian/Ubuntu + updates=$(apt list --upgradable 2>/dev/null | grep -v "Listing..." | wc -l) + if [ "$updates" -eq 0 ]; then + print_status "System is up to date" "ok" + else + print_status "$updates updates available" "warning" + fi +elif command -v yum &> /dev/null; then + # CentOS/RHEL + updates=$(yum check-update --quiet | grep -v "^$" | wc -l) + if [ "$updates" -eq 0 ]; then + print_status "System is up to date" "ok" + else + print_status "$updates updates available" "warning" + fi +else + echo "Package manager not detected, skipping update check" +fi + +# Security Checks +print_header "Security Checks" + +# Check SSH root login +if [ -f /etc/ssh/sshd_config ]; then + if grep -q "PermitRootLogin yes" /etc/ssh/sshd_config; then + print_status "SSH root login is enabled (security risk)" "error" + else + print_status "SSH root login is disabled" "ok" + fi +fi + +# Check for listening ports +print_header "Open Ports" +if command -v netstat &> /dev/null; then + netstat -tuln | grep LISTEN +elif command -v ss &> /dev/null; then + ss -tuln | grep LISTEN +else + echo "Neither netstat nor ss found, skipping port check" +fi + +# Summary +print_header "System Health Summary" +# Check overall health based on previous checks +if [ "$mem_usage_percent" -lt 85 ] && [ "$failed_services" -eq 0 ]; then + print_status "System appears to be healthy" "ok" +else + print_status "System needs attention" "warning" +fi + +echo -e "\nReport generated on $(date)" diff --git a/snippets/system-design/microservices_example.js b/snippets/system-design/microservices_example.js new file mode 100644 index 0000000..92e0d24 --- /dev/null +++ b/snippets/system-design/microservices_example.js @@ -0,0 +1,595 @@ +/** + * Microservices Architecture Example + * + * This file demonstrates a simple implementation of microservices + * for an e-commerce application using Node.js and Express. + */ + +// Product Service +const productServiceCode = ` +const express = require('express'); +const mongoose = require('mongoose'); +const app = express(); +const PORT = process.env.PORT || 3001; + +// MongoDB connection +mongoose.connect('mongodb://product-db:27017/productdb', { + useNewUrlParser: true, + useUnifiedTopology: true +}); + +// Product schema +const productSchema = new mongoose.Schema({ + id: String, + name: String, + description: String, + price: Number, + category: String, + inventory: Number +}); + +const Product = mongoose.model('Product', productSchema); + +app.use(express.json()); + +// Health check endpoint +app.get('/health', (req, res) => { + res.status(200).json({ status: 'ok' }); +}); + +// Get all products +app.get('/api/products', async (req, res) => { + try { + const products = await Product.find(); + res.json(products); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +// Get product by ID +app.get('/api/products/:id', async (req, res) => { + try { + const product = await Product.findOne({ id: req.params.id }); + if (!product) { + return res.status(404).json({ error: 'Product not found' }); + } + res.json(product); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +// Create product +app.post('/api/products', async (req, res) => { + try { + const product = new Product(req.body); + await product.save(); + + // Publish event to message broker (RabbitMQ) + const amqp = require('amqplib'); + const connection = await amqp.connect('amqp://rabbitmq'); + const channel = await connection.createChannel(); + const exchange = 'product-events'; + + await channel.assertExchange(exchange, 'topic', { durable: true }); + channel.publish( + exchange, + 'product.created', + Buffer.from(JSON.stringify({ + event: 'PRODUCT_CREATED', + data: product + })) + ); + + await channel.close(); + await connection.close(); + + res.status(201).json(product); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +// Update product inventory +app.patch('/api/products/:id/inventory', async (req, res) => { + try { + const { quantity } = req.body; + const product = await Product.findOne({ id: req.params.id }); + + if (!product) { + return res.status(404).json({ error: 'Product not found' }); + } + + product.inventory += quantity; + await product.save(); + res.json(product); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +app.listen(PORT, () => { + console.log(\`Product service running on port \${PORT}\`); +}); +`; + +// Order Service +const orderServiceCode = ` +const express = require('express'); +const mongoose = require('mongoose'); +const axios = require('axios'); +const app = express(); +const PORT = process.env.PORT || 3002; + +// MongoDB connection +mongoose.connect('mongodb://order-db:27017/orderdb', { + useNewUrlParser: true, + useUnifiedTopology: true +}); + +// Order schema +const orderSchema = new mongoose.Schema({ + id: String, + customerId: String, + items: [{ + productId: String, + quantity: Number, + price: Number + }], + totalAmount: Number, + status: String, + createdAt: { type: Date, default: Date.now } +}); + +const Order = mongoose.model('Order', orderSchema); + +app.use(express.json()); + +// Health check endpoint +app.get('/health', (req, res) => { + res.status(200).json({ status: 'ok' }); +}); + +// Create order +app.post('/api/orders', async (req, res) => { + try { + const { customerId, items } = req.body; + + // Validate customer via Customer Service + try { + await axios.get(\`http://customer-service:3003/api/customers/\${customerId}\`); + } catch (error) { + return res.status(400).json({ error: 'Invalid customer ID' }); + } + + // Check product availability and calculate total + let totalAmount = 0; + for (const item of items) { + try { + const productResponse = await axios.get( + \`http://product-service:3001/api/products/\${item.productId}\` + ); + const product = productResponse.data; + + if (product.inventory < item.quantity) { + return res.status(400).json({ + error: \`Insufficient inventory for product \${item.productId}\` + }); + } + + item.price = product.price; + totalAmount += product.price * item.quantity; + } catch (error) { + return res.status(400).json({ + error: \`Invalid product ID: \${item.productId}\` + }); + } + } + + // Create order + const order = new Order({ + id: \`ORD-\${Date.now()}\`, + customerId, + items, + totalAmount, + status: 'PENDING' + }); + + await order.save(); + + // Update inventory + for (const item of items) { + await axios.patch( + \`http://product-service:3001/api/products/\${item.productId}/inventory\`, + { quantity: -item.quantity } + ); + } + + // Publish event to message broker (RabbitMQ) + const amqp = require('amqplib'); + const connection = await amqp.connect('amqp://rabbitmq'); + const channel = await connection.createChannel(); + const exchange = 'order-events'; + + await channel.assertExchange(exchange, 'topic', { durable: true }); + channel.publish( + exchange, + 'order.created', + Buffer.from(JSON.stringify({ + event: 'ORDER_CREATED', + data: order + })) + ); + + await channel.close(); + await connection.close(); + + res.status(201).json(order); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +// Get order by ID +app.get('/api/orders/:id', async (req, res) => { + try { + const order = await Order.findOne({ id: req.params.id }); + if (!order) { + return res.status(404).json({ error: 'Order not found' }); + } + res.json(order); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +// Get customer orders +app.get('/api/orders/customer/:customerId', async (req, res) => { + try { + const orders = await Order.find({ customerId: req.params.customerId }); + res.json(orders); + } catch (err) { + res.status(500).json({ error: err.message }); + } +}); + +app.listen(PORT, () => { + console.log(\`Order service running on port \${PORT}\`); +}); +`; + +// API Gateway +const apiGatewayCode = ` +const express = require('express'); +const { createProxyMiddleware } = require('http-proxy-middleware'); +const app = express(); +const PORT = process.env.PORT || 3000; + +// Authentication middleware +const authenticate = (req, res, next) => { + const authHeader = req.headers.authorization; + + if (!authHeader) { + return res.status(401).json({ error: 'Authorization header missing' }); + } + + // In a real application, you would validate the token + // For this example, we'll just check if it exists + const token = authHeader.split(' ')[1]; + if (!token) { + return res.status(401).json({ error: 'Invalid token format' }); + } + + // Add user info to request for downstream services + req.user = { id: 'user-123' }; // This would come from token validation + next(); +}; + +// Rate limiting middleware +const rateLimit = require('express-rate-limit'); +const limiter = rateLimit({ + windowMs: 15 * 60 * 1000, // 15 minutes + max: 100 // limit each IP to 100 requests per windowMs +}); + +// Apply rate limiting to all requests +app.use(limiter); + +// Health check endpoint +app.get('/health', (req, res) => { + res.status(200).json({ status: 'ok' }); +}); + +// Product Service routes +app.use( + '/api/products', + authenticate, + createProxyMiddleware({ + target: 'http://product-service:3001', + changeOrigin: true, + pathRewrite: { + '^/api/products': '/api/products' + } + }) +); + +// Order Service routes +app.use( + '/api/orders', + authenticate, + createProxyMiddleware({ + target: 'http://order-service:3002', + changeOrigin: true, + pathRewrite: { + '^/api/orders': '/api/orders' + } + }) +); + +// Customer Service routes +app.use( + '/api/customers', + authenticate, + createProxyMiddleware({ + target: 'http://customer-service:3003', + changeOrigin: true, + pathRewrite: { + '^/api/customers': '/api/customers' + } + }) +); + +app.listen(PORT, () => { + console.log(\`API Gateway running on port \${PORT}\`); +}); +`; + +// Notification Service (Event Consumer) +const notificationServiceCode = ` +const amqp = require('amqplib'); +const nodemailer = require('nodemailer'); + +// Create a test SMTP service +const transporter = nodemailer.createTransport({ + host: 'smtp.ethereal.email', + port: 587, + auth: { + user: 'testuser@ethereal.email', + pass: 'testpassword' + } +}); + +async function startConsumer() { + try { + // Connect to RabbitMQ + const connection = await amqp.connect('amqp://rabbitmq'); + const channel = await connection.createChannel(); + + // Set up exchanges + const orderExchange = 'order-events'; + const productExchange = 'product-events'; + + await channel.assertExchange(orderExchange, 'topic', { durable: true }); + await channel.assertExchange(productExchange, 'topic', { durable: true }); + + // Create queue for notification service + const queue = 'notification-service'; + await channel.assertQueue(queue, { durable: true }); + + // Bind queue to exchanges with routing keys + await channel.bindQueue(queue, orderExchange, 'order.*'); + await channel.bindQueue(queue, productExchange, 'product.*'); + + console.log('Notification service waiting for messages...'); + + // Consume messages + channel.consume(queue, async (msg) => { + if (msg !== null) { + const content = JSON.parse(msg.content.toString()); + console.log(\`Received event: \${content.event}\`); + + switch (content.event) { + case 'ORDER_CREATED': + await sendOrderConfirmation(content.data); + break; + case 'PRODUCT_CREATED': + await notifyAdminAboutNewProduct(content.data); + break; + default: + console.log(\`Unknown event type: \${content.event}\`); + } + + channel.ack(msg); + } + }); + } catch (error) { + console.error('Error in notification service:', error); + } +} + +async function sendOrderConfirmation(order) { + try { + const mailOptions = { + from: 'noreply@example.com', + to: \`customer-\${order.customerId}@example.com\`, // In a real app, get from customer service + subject: \`Order Confirmation: \${order.id}\`, + text: \` + Thank you for your order! + + Order ID: \${order.id} + Total Amount: $\${order.totalAmount.toFixed(2)} + Status: \${order.status} + + Items: + \${order.items.map(item => \`- Product \${item.productId}: \${item.quantity} x $\${item.price.toFixed(2)}\`).join('\\n')} + + Thank you for shopping with us! + \` + }; + + await transporter.sendMail(mailOptions); + console.log(\`Order confirmation email sent for order \${order.id}\`); + } catch (error) { + console.error('Error sending order confirmation:', error); + } +} + +async function notifyAdminAboutNewProduct(product) { + try { + const mailOptions = { + from: 'noreply@example.com', + to: 'admin@example.com', + subject: 'New Product Added', + text: \` + A new product has been added to the catalog: + + ID: \${product.id} + Name: \${product.name} + Price: $\${product.price.toFixed(2)} + Category: \${product.category} + Initial Inventory: \${product.inventory} + \` + }; + + await transporter.sendMail(mailOptions); + console.log(\`Admin notification sent for new product \${product.id}\`); + } catch (error) { + console.error('Error sending admin notification:', error); + } +} + +// Start the consumer +startConsumer(); +`; + +// Docker Compose file for the microservices +const dockerComposeCode = ` +version: '3' + +services: + # API Gateway + api-gateway: + build: ./api-gateway + ports: + - "3000:3000" + depends_on: + - product-service + - order-service + - customer-service + environment: + - PORT=3000 + networks: + - microservices-network + + # Product Service + product-service: + build: ./product-service + ports: + - "3001:3001" + depends_on: + - product-db + - rabbitmq + environment: + - PORT=3001 + - MONGODB_URI=mongodb://product-db:27017/productdb + - RABBITMQ_URI=amqp://rabbitmq + networks: + - microservices-network + + # Order Service + order-service: + build: ./order-service + ports: + - "3002:3002" + depends_on: + - order-db + - product-service + - customer-service + - rabbitmq + environment: + - PORT=3002 + - MONGODB_URI=mongodb://order-db:27017/orderdb + - RABBITMQ_URI=amqp://rabbitmq + networks: + - microservices-network + + # Customer Service + customer-service: + build: ./customer-service + ports: + - "3003:3003" + depends_on: + - customer-db + environment: + - PORT=3003 + - MONGODB_URI=mongodb://customer-db:27017/customerdb + networks: + - microservices-network + + # Notification Service + notification-service: + build: ./notification-service + depends_on: + - rabbitmq + environment: + - RABBITMQ_URI=amqp://rabbitmq + - SMTP_HOST=smtp.ethereal.email + - SMTP_PORT=587 + - SMTP_USER=testuser@ethereal.email + - SMTP_PASS=testpassword + networks: + - microservices-network + + # Databases + product-db: + image: mongo:4.4 + volumes: + - product-db-data:/data/db + networks: + - microservices-network + + order-db: + image: mongo:4.4 + volumes: + - order-db-data:/data/db + networks: + - microservices-network + + customer-db: + image: mongo:4.4 + volumes: + - customer-db-data:/data/db + networks: + - microservices-network + + # Message Broker + rabbitmq: + image: rabbitmq:3-management + ports: + - "5672:5672" # AMQP port + - "15672:15672" # Management UI + networks: + - microservices-network + +networks: + microservices-network: + driver: bridge + +volumes: + product-db-data: + order-db-data: + customer-db-data: +`; + +// Export the code examples +module.exports = { + productServiceCode, + orderServiceCode, + apiGatewayCode, + notificationServiceCode, + dockerComposeCode +}; + +// This file is just a demonstration of microservices code examples +// In a real project, each service would be in its own directory diff --git a/snippets/testing/unit_testing_example.js b/snippets/testing/unit_testing_example.js new file mode 100644 index 0000000..fe33bcc --- /dev/null +++ b/snippets/testing/unit_testing_example.js @@ -0,0 +1,459 @@ +/** + * Unit Testing Example with Jest + * + * This file demonstrates unit testing principles using Jest for a simple + * shopping cart implementation. + */ + +// ShoppingCart.js - The module we're testing +class ShoppingCart { + constructor() { + this.items = []; + } + + addItem(item) { + if (!item.id || !item.name || typeof item.price !== 'number' || item.price <= 0) { + throw new Error('Invalid item format'); + } + + const existingItem = this.items.find(i => i.id === item.id); + + if (existingItem) { + existingItem.quantity += item.quantity || 1; + } else { + this.items.push({ + ...item, + quantity: item.quantity || 1 + }); + } + + return this.items; + } + + removeItem(itemId) { + const initialLength = this.items.length; + this.items = this.items.filter(item => item.id !== itemId); + + return initialLength !== this.items.length; + } + + updateQuantity(itemId, quantity) { + if (typeof quantity !== 'number' || quantity <= 0) { + throw new Error('Quantity must be a positive number'); + } + + const item = this.items.find(item => item.id === itemId); + + if (!item) { + return false; + } + + item.quantity = quantity; + return true; + } + + getTotal() { + return this.items.reduce((total, item) => { + return total + (item.price * item.quantity); + }, 0); + } + + getItemCount() { + return this.items.reduce((count, item) => count + item.quantity, 0); + } + + clear() { + this.items = []; + } + + applyDiscount(percentage) { + if (typeof percentage !== 'number' || percentage < 0 || percentage > 100) { + throw new Error('Discount percentage must be between 0 and 100'); + } + + const discountFactor = 1 - (percentage / 100); + return this.getTotal() * discountFactor; + } +} + +// ShoppingCart.test.js - Unit tests for the ShoppingCart class +describe('ShoppingCart', () => { + let cart; + + // Setup - Runs before each test + beforeEach(() => { + cart = new ShoppingCart(); + }); + + // Test adding items + describe('addItem', () => { + test('should add a new item to the cart', () => { + // Arrange + const item = { id: '1', name: 'Product 1', price: 10 }; + + // Act + cart.addItem(item); + + // Assert + expect(cart.items).toHaveLength(1); + expect(cart.items[0]).toEqual({ id: '1', name: 'Product 1', price: 10, quantity: 1 }); + }); + + test('should increase quantity when adding an existing item', () => { + // Arrange + const item = { id: '1', name: 'Product 1', price: 10 }; + + // Act + cart.addItem(item); + cart.addItem(item); + + // Assert + expect(cart.items).toHaveLength(1); + expect(cart.items[0].quantity).toBe(2); + }); + + test('should respect the quantity property when provided', () => { + // Arrange + const item = { id: '1', name: 'Product 1', price: 10, quantity: 5 }; + + // Act + cart.addItem(item); + + // Assert + expect(cart.items).toHaveLength(1); + expect(cart.items[0].quantity).toBe(5); + }); + + test('should throw an error for invalid item format', () => { + // Arrange + const invalidItems = [ + { name: 'Missing ID', price: 10 }, + { id: '1', price: 10 }, + { id: '1', name: 'Invalid Price', price: -5 }, + { id: '1', name: 'Invalid Price Type', price: '10' } + ]; + + // Act & Assert + invalidItems.forEach(item => { + expect(() => cart.addItem(item)).toThrow('Invalid item format'); + }); + }); + }); + + // Test removing items + describe('removeItem', () => { + test('should remove an item from the cart', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10 }); + + // Act + const result = cart.removeItem('1'); + + // Assert + expect(result).toBe(true); + expect(cart.items).toHaveLength(0); + }); + + test('should return false when trying to remove a non-existent item', () => { + // Act + const result = cart.removeItem('nonexistent'); + + // Assert + expect(result).toBe(false); + }); + }); + + // Test updating quantities + describe('updateQuantity', () => { + test('should update the quantity of an existing item', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10 }); + + // Act + const result = cart.updateQuantity('1', 3); + + // Assert + expect(result).toBe(true); + expect(cart.items[0].quantity).toBe(3); + }); + + test('should return false when trying to update a non-existent item', () => { + // Act + const result = cart.updateQuantity('nonexistent', 3); + + // Assert + expect(result).toBe(false); + }); + + test('should throw an error for invalid quantity', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10 }); + + // Act & Assert + expect(() => cart.updateQuantity('1', -1)).toThrow('Quantity must be a positive number'); + expect(() => cart.updateQuantity('1', 'invalid')).toThrow('Quantity must be a positive number'); + }); + }); + + // Test calculating totals + describe('getTotal', () => { + test('should calculate the total price of all items', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10, quantity: 2 }); + cart.addItem({ id: '2', name: 'Product 2', price: 15, quantity: 1 }); + + // Act + const total = cart.getTotal(); + + // Assert + expect(total).toBe(35); // (10 * 2) + (15 * 1) = 35 + }); + + test('should return 0 for an empty cart', () => { + // Act + const total = cart.getTotal(); + + // Assert + expect(total).toBe(0); + }); + }); + + // Test item count + describe('getItemCount', () => { + test('should return the total number of items in the cart', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10, quantity: 2 }); + cart.addItem({ id: '2', name: 'Product 2', price: 15, quantity: 3 }); + + // Act + const count = cart.getItemCount(); + + // Assert + expect(count).toBe(5); // 2 + 3 = 5 + }); + + test('should return 0 for an empty cart', () => { + // Act + const count = cart.getItemCount(); + + // Assert + expect(count).toBe(0); + }); + }); + + // Test clearing the cart + describe('clear', () => { + test('should remove all items from the cart', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 10 }); + cart.addItem({ id: '2', name: 'Product 2', price: 15 }); + + // Act + cart.clear(); + + // Assert + expect(cart.items).toHaveLength(0); + expect(cart.getTotal()).toBe(0); + }); + }); + + // Test applying discounts + describe('applyDiscount', () => { + test('should apply the correct discount to the total', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 100 }); + + // Act + const discountedTotal = cart.applyDiscount(20); // 20% discount + + // Assert + expect(discountedTotal).toBe(80); + }); + + test('should throw an error for invalid discount percentage', () => { + // Arrange + cart.addItem({ id: '1', name: 'Product 1', price: 100 }); + + // Act & Assert + expect(() => cart.applyDiscount(-10)).toThrow('Discount percentage must be between 0 and 100'); + expect(() => cart.applyDiscount(110)).toThrow('Discount percentage must be between 0 and 100'); + expect(() => cart.applyDiscount('20')).toThrow('Discount percentage must be between 0 and 100'); + }); + }); + + // Integration test for multiple operations + describe('integration', () => { + test('should handle a sequence of cart operations correctly', () => { + // Add items + cart.addItem({ id: '1', name: 'Product 1', price: 10, quantity: 2 }); + cart.addItem({ id: '2', name: 'Product 2', price: 15 }); + expect(cart.getItemCount()).toBe(3); + expect(cart.getTotal()).toBe(35); + + // Update quantity + cart.updateQuantity('2', 3); + expect(cart.getItemCount()).toBe(5); + expect(cart.getTotal()).toBe(65); // (10 * 2) + (15 * 3) = 65 + + // Remove an item + cart.removeItem('1'); + expect(cart.getItemCount()).toBe(3); + expect(cart.getTotal()).toBe(45); // 15 * 3 = 45 + + // Apply discount + const discountedTotal = cart.applyDiscount(10); + expect(discountedTotal).toBe(40.5); // 45 - 10% = 40.5 + }); + }); +}); + +// Example of using test doubles +describe('ShoppingCart with test doubles', () => { + // Example of using a spy + test('should call external service when adding item (spy example)', () => { + // Arrange + const notificationService = { + notifyItemAdded: jest.fn() + }; + + class ShoppingCartWithNotifications extends ShoppingCart { + addItem(item) { + const result = super.addItem(item); + notificationService.notifyItemAdded(item); + return result; + } + } + + const cart = new ShoppingCartWithNotifications(); + const item = { id: '1', name: 'Product 1', price: 10 }; + + // Act + cart.addItem(item); + + // Assert + expect(notificationService.notifyItemAdded).toHaveBeenCalledWith(item); + }); + + // Example of using a stub + test('should apply tax rate from tax service (stub example)', () => { + // Arrange + const taxServiceStub = { + getTaxRate: () => 0.1 // 10% tax rate + }; + + class ShoppingCartWithTax extends ShoppingCart { + constructor(taxService) { + super(); + this.taxService = taxService; + } + + getTotalWithTax() { + const subtotal = this.getTotal(); + const taxRate = this.taxService.getTaxRate(); + return subtotal * (1 + taxRate); + } + } + + const cart = new ShoppingCartWithTax(taxServiceStub); + cart.addItem({ id: '1', name: 'Product 1', price: 100 }); + + // Act + const totalWithTax = cart.getTotalWithTax(); + + // Assert + expect(totalWithTax).toBe(110); // 100 + 10% tax = 110 + }); + + // Example of using a mock + test('should validate inventory before adding item (mock example)', () => { + // Arrange + const inventoryServiceMock = { + checkAvailability: jest.fn() + }; + + class ShoppingCartWithInventory extends ShoppingCart { + constructor(inventoryService) { + super(); + this.inventoryService = inventoryService; + } + + addItemWithInventoryCheck(item) { + const isAvailable = this.inventoryService.checkAvailability(item.id, item.quantity || 1); + if (isAvailable) { + return super.addItem(item); + } + throw new Error('Item not available in requested quantity'); + } + } + + const cart = new ShoppingCartWithInventory(inventoryServiceMock); + const item = { id: '1', name: 'Product 1', price: 10, quantity: 2 }; + + // Setup mock behavior + inventoryServiceMock.checkAvailability.mockReturnValueOnce(true); + + // Act + cart.addItemWithInventoryCheck(item); + + // Assert + expect(inventoryServiceMock.checkAvailability).toHaveBeenCalledWith('1', 2); + }); + + // Example of using a fake + test('should persist cart items to storage (fake example)', () => { + // Arrange + class FakeStorage { + constructor() { + this.data = {}; + } + + setItem(key, value) { + this.data[key] = value; + } + + getItem(key) { + return this.data[key] || null; + } + } + + class ShoppingCartWithStorage extends ShoppingCart { + constructor(storage) { + super(); + this.storage = storage; + this.loadFromStorage(); + } + + loadFromStorage() { + const savedItems = this.storage.getItem('cart-items'); + if (savedItems) { + this.items = JSON.parse(savedItems); + } + } + + saveToStorage() { + this.storage.setItem('cart-items', JSON.stringify(this.items)); + } + + addItem(item) { + const result = super.addItem(item); + this.saveToStorage(); + return result; + } + } + + const fakeStorage = new FakeStorage(); + const cart = new ShoppingCartWithStorage(fakeStorage); + const item = { id: '1', name: 'Product 1', price: 10 }; + + // Act + cart.addItem(item); + + // Assert + expect(JSON.parse(fakeStorage.getItem('cart-items'))).toEqual([ + { id: '1', name: 'Product 1', price: 10, quantity: 1 } + ]); + }); +}); + +// Export the ShoppingCart class +module.exports = ShoppingCart; \ No newline at end of file diff --git a/tools/check_links.sh b/tools/check_links.sh new file mode 100755 index 0000000..7d7daad --- /dev/null +++ b/tools/check_links.sh @@ -0,0 +1,108 @@ +#!/bin/bash +# +# Link Checker Script +# +# This script checks for broken links in markdown files within the repository. +# It uses markdown-link-check to validate both internal and external links. +# +# Usage: +# ./check_links.sh [directory] +# +# If no directory is specified, it will check all markdown files in the repo. +# +# Requirements: +# - npm (Node Package Manager) +# - markdown-link-check (will be installed if not present) +# + +set -e + +# Default search directory is the repo root +SEARCH_DIR=${1:-$(git rev-parse --show-toplevel)} + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[0;33m' +NC='\033[0m' # No Color + +echo -e "${YELLOW}=== Tech Notes Hub Link Checker ===${NC}" + +# Check if markdown-link-check is installed, if not install it +if ! command -v markdown-link-check &> /dev/null; then + echo -e "${YELLOW}markdown-link-check not found. Installing...${NC}" + npm install -g markdown-link-check +fi + +# Configuration file for markdown-link-check +CONFIG_FILE=$(mktemp) +cat > "$CONFIG_FILE" << EOF +{ + "ignorePatterns": [ + { + "pattern": "^#" + }, + { + "pattern": "^mailto:" + } + ], + "replacementPatterns": [ + { + "pattern": "^/", + "replacement": "file://$(pwd)/" + } + ], + "timeout": "5s", + "retryOn429": true, + "retryCount": 3, + "fallbackRetryDelay": "30s" +} +EOF + +# Find all markdown files in the specified directory +echo -e "${YELLOW}Searching for markdown files in ${SEARCH_DIR}...${NC}" +FILES=$(find "$SEARCH_DIR" -name "*.md" | sort) + +if [ -z "$FILES" ]; then + echo -e "${RED}No markdown files found in ${SEARCH_DIR}${NC}" + rm "$CONFIG_FILE" + exit 1 +fi + +TOTAL_FILES=$(echo "$FILES" | wc -l) +TOTAL_FILES=$(echo "$TOTAL_FILES" | tr -d '[:space:]') +echo -e "${GREEN}Found ${TOTAL_FILES} markdown files to check${NC}" + +# Variables to track results +PASSED=0 +FAILED=0 +FAILED_FILES="" + +# Process each file +for FILE in $FILES; do + echo -e "${YELLOW}Checking links in ${FILE}...${NC}" + + # Run markdown-link-check + if markdown-link-check --config "$CONFIG_FILE" "$FILE" | grep -q "ERROR"; then + echo -e "${RED}❌ Failed: ${FILE}${NC}" + FAILED=$((FAILED+1)) + FAILED_FILES="${FAILED_FILES}\n${FILE}" + else + echo -e "${GREEN}✅ Passed: ${FILE}${NC}" + PASSED=$((PASSED+1)) + fi +done + +# Clean up +rm "$CONFIG_FILE" + +# Print summary +echo -e "\n${YELLOW}=== Summary ===${NC}" +echo -e "${GREEN}✅ ${PASSED} files passed${NC}" +if [ $FAILED -gt 0 ]; then + echo -e "${RED}❌ ${FAILED} files failed:${FAILED_FILES}${NC}" + exit 1 +else + echo -e "${GREEN}All links are valid!${NC}" + exit 0 +fi \ No newline at end of file diff --git a/tools/generate_summary.py b/tools/generate_summary.py new file mode 100755 index 0000000..25e8f07 --- /dev/null +++ b/tools/generate_summary.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +""" +Script to automatically generate SUMMARY.md by scanning the docs/ directory. +""" + +import os +import re +from pathlib import Path + +def generate_summary(): + """Generate summary based on docs structure""" + docs_dir = Path("docs") + summary_path = Path("SUMMARY.md") + + # Start with header + summary_content = "# Tech Notes Hub\n\n" + summary_content += "## Table of Contents\n\n" + + # Process each directory in docs/ + for path in sorted(docs_dir.glob("*")): + if path.is_dir(): + dir_name = path.name + pretty_dir_name = dir_name.replace('-', ' ').title() + summary_content += f"### {pretty_dir_name}\n\n" + + # Process files in the directory + for file in sorted(path.glob("*.md")): + file_name = file.stem + + # Skip files that start with underscore (like _category_.json files) + if file_name.startswith('_'): + continue + + # Get the title from the file's first heading + title = get_title_from_file(file) + if not title: + title = file_name.replace('-', ' ').title() + + relative_path = os.path.join(path.name, file.name) + summary_content += f"- [{title}](docs/{relative_path})\n" + + summary_content += "\n" + + # Write the summary file + with open(summary_path, "w", encoding="utf-8") as f: + f.write(summary_content) + + print(f"Generated {summary_path}") + +def get_title_from_file(file_path): + """Extract the title from the first heading in the file""" + try: + with open(file_path, "r", encoding="utf-8") as f: + content = f.read() + # Look for first # heading + match = re.search(r'^# (.+)$', content, re.MULTILINE) + if match: + return match.group(1) + except Exception as e: + print(f"Warning: Could not extract title from {file_path}: {e}") + + return None + +if __name__ == "__main__": + generate_summary() \ No newline at end of file