Book Image

D Cookbook

By : Adam Ruppe
Book Image

D Cookbook

By: Adam Ruppe

Overview of this book

Related Content you might be interested in

Current Title:

Small book image
D Cookbook
Adam Ruppe
May, 2014 | 362 pages
No titles found
Table of Contents (21 chapters)
D Cookbook
D Cookbook
Credits
Credits
Foreword
Foreword
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Core Tasks
Core Tasks
Introduction
Installing the compiler and writing a "Hello World" program
Adding additional modules (files) to your program
Using external libraries
Building and processing arrays
Using associative arrays to translate input
Creating a user-defined vector type
Using a custom exception type
Understanding immutability
Slicing a string to get a substring
Creating a tree of classes
2
Phobos – The Standard Library
Phobos – The Standard Library
Introduction
Performing type conversions
Finding the largest files in a directory
Creating a network client and server
Using Base64 to create a data URI
Generating random numbers
Normalizing a string and performing Unicode comparisons
Searching with regular expressions
Writing a digest utility
Using the std.zlib compression
Using the std.json module
3
Ranges
Ranges
Introduction
Using ranges when implementing an algorithm
Creating an input range
Creating an output range
Creating a higher-order range
Putting a range interface on a collection
Creating an input range over a tree structure
Using runtime polymorphic (class) ranges
Storing a range as a data member
Sorting ranges efficiently
Searching ranges
Using functional tools to query data
4
Integration
Integration
Introduction
Calling the Windows API functions
Removing the Windows console
Making Linux system calls
Writing part of a C program in D
Interfacing with C++
Using structs to mimic the C++ object structure
Communicating with external processes
Communicating with a dynamic scripting language
Using Windows' COM
5
Resource Management
Resource Management
Introduction
Avoiding the garbage collector
Making a reference-counted object
Manually managing class memory
Using scope guards to manage transactions
Creating an array replacement
Managing lent resources
Creating a NotNull struct
Using unique pointers
Using RAII and handling the limitations of class destructors
6
Wrapped Types
Wrapped Types
Introduction
Creating a struct with reference semantics
Simulating inheritance with structs
Creating a ranged integer
Creating an opaque handle type
Creating a subtyped string for i18n
Forwarding methods with opDispatch
Creating a tagged dynamic type
Creating a structure with two views into the same data
Simulating multiple inheritance with mixin templates
7
Correctness Checking
Correctness Checking
Introduction
Using assertions and exceptions
Using static asserts
Using template constraints and static if
Preventing memory corruption bugs with @safe
Leveraging const-correctness
Avoiding side effects of pure functions
Verifying object invariants and pre- and post-conditions
Unit testing your code
Documenting your code with Ddoc
Writing platform-specific code (versions) and per-client configuration modules
8
Reflection
Reflection
Introduction
Getting dynamic runtime type information
Getting a list of child classes
Determining whether a module is available
Getting a list of all methods or fields in a module or an object
Inspecting function overloads
Determining names, types, and default values of function parameters
Getting components of complex types
Using user-defined attributes
Implementing a custom lint-style check for virtual functions
Extending the runtime type information
Creating a command-line function caller
9
Code Generation
Code Generation
Introduction
Creating user-defined literals
Parsing a domain-specific language
Generating data structures from text diagrams
Automating dynamic calls with multiple dispatch
Building a lookup table
Using string parameters to change functions
Wrapping instance methods
Using opDispatch to generate properties
Duck typing to a statically-defined interface
10
Multitasking
Multitasking
Introduction
Using threads
Passing messages with std.concurrency
Processing parallel data with std.parallelism
Using fibers
Creating new processes
Exploring thread-safe, single-locking singletons
Using asynchronous I/O
11
D for Kernel Coding
D for Kernel Coding
Introduction
Running D on bare metal x86 with a stripped runtime
Adding interrupt handling to the bare metal x86 code
12
Web and GUI Programming
Web and GUI Programming
Introduction
Creating a dynamic website with cgi.d
Creating a web API with web.d
Parsing and modifying an HTML page with dom.d
Accessing a SQL database
Sending an e-mail
Writing colored output to the console
Getting real-time input from the terminal
Working with image files
Creating a graphics window to show a TV static demo
Creating an OpenGL window
Addendum
Addendum
Compiling D for ARM/Linux Raspberry Pi
Running D on bare metal ARM
Using the exponentiation operator
Getting a stack trace without throwing an exception
Finding more information about D
Index
Index

Chapter 8. Reflection

D supports limited runtime reflection out of the box as well as rich compile-time reflection that can be used in code generation efforts, custom semantic checks, building additional runtime reflection information, and more. In this chapter, we'll be covering the following recipes:

  • Getting dynamic runtime type information

  • Getting a list of child classes

  • Determining whether a module is available

  • Getting a list of all methods or fields in a module or an object

  • Inspecting function overloads

  • Determining names, types, and default values of function parameters

  • Getting components of complex types

  • Using user-defined attributes

  • Implementing a custom lint-style check for virtual functions

  • Extending the runtime type information

  • Creating a command-line function caller

Previous Section
End of Section 1
Next Section