Posts on toeb / notes

Unit tests for 3D

Sun, 11 Oct 2026 00:00:00 +0000

I wanted to 3D-print an ampoule case for my wife, and it fit on the first print. The trick was not the CAD. A verification harness checked every design virtually before the printer saw it. You choose which ampoules and how many; the generator either packs them into a fixed case or designs the smallest case that holds them.

Try it: paramcad designer, which runs entirely in your browser.

From CAD to print

The printed case is the fork-clip version: two 10 ml and four 2 ml ampoules in a 121.5 × 121.5 mm PETG case. It went together on the first print. Only the closing clamps and the clips showed small deviations, which is exactly what the outer loop below turns into calibration data and new rules.

cmakepp: Expression Syntax

Mon, 04 Jun 2018 00:00:00 +0000

“CMake’s syntax is not sexy.” Is a statement that probably everyone can understand. It does not allow the developer rudimentary constructs which almost all other languages have. But because CMake’s language is astonishingly flexible I was able to create a lexer and parser and interpreter for a custom 100 % compatible syntax which (once “JIT transpiled”) is also fast. I call it cmakepp expressions or expr for short. I want to emphasize that all of this is written in 100% compatible cmake code and you can use it without the need to preprocess any cmake files or adding any dependencies (except cmakepp).

Modern CMake Slides

Tue, 30 Aug 2016 00:00:00 +0000

I’ve held a Presentation about “modern CMake” at the C++ Meetup in Wiesbaden a week ago and wanted to share the slides with the Internet. I try to highlight the parts of a CMake project which I consider as modern (I guess there is room for interpretation here)

I give a small introduction to CMake command line, script mode and then mostly about targets, scoping etc. Of course you cannot hear my voice but maybe the slides themselves can give you some insight. There is also a small github repository added in which I added a few examples which I talk about in the slides. I plan to extend these CMake examples and add some documentation because CMake seems to be lacking small well configured projects from which C++ developers start (copy) from ;).

cmakepp: reflecting and manipulating CMakeLists

Thu, 19 Mar 2015 00:00:00 +0000

The basic CMakeLists.txt files for cmake based projects are usually very simple. Their manipulation lends itself to be automated and for this purpose I developed a parser for cmake script which allows you to manipulate it programatically from within cmake itself. On top of the cmake script parser I generated utility functions which allow you to manipulate CMakeLists.txt files while still allowing you to manually working on them. This functionality is wrapped by a command line interface which I present to you in this post. You can find this part of cmakepp here. Feel free to try and please give me feedback if you like it or find any bugs.

cmakepp: Template Generation in CMake

Wed, 11 Feb 2015 00:00:00 +0000

Find it at http://github.com/toeb/cmakepp

Download cmakepp standalone file here

As with all my work I appreciate all feedback given and am particularly happy about virtual internet points 🙂

To the Post: While working on the documentation of cmakepp I grew wary of always doubling the documentation – one in the source code and a mirror in the README.md. Also I was frustrated when I refactored and renamed functions or changed signatures which is not uncommon – especially when working on a new feature. So I needed a tool which could generate the documentation by copying the comment header and the function signature from my CMake files.

Heterogeneous Package Search and Retrieval in CMake

Wed, 04 Feb 2015 00:00:00 +0000

Finding and Retrieving third party sources, tools and binaries is currently a hot subject for C++. There are quite a few solutions (biicode, cpm, hunter, …) Also there is github, bitbucket, source balls etc. Further there are many package managers for many different platforms which also can contain packages (apt-get, chocolatey, nuget, npm, pip, ….). So everything is very decentralized and heterogeneous.

On the other hand there is CMake the standard when it comes to creating platform independent projects for various build and developer environments. (of course it is not the only build tool but it is the standard for platform independent C/C++ projects) Most notably it generates MSBuild for Visual Studio and MAKE output which are the most commonly used build systems. CMake is as platform independent as it comes.

Parallel Processes in CMake

Tue, 16 Dec 2014 00:00:00 +0000

If you need to check out multiple large repositories or build and install large separate projects you might want to use parallel processes in CMake. Dividing your tasks to use multiple CMake and or other processes can speed up your build and configuration steps immensely.

Since all cmake host OSs support multitasking from the command line it is possible to use cmake to contol them in turn. Using this approach I implemented a ‘platform independent’ control mechanism for starting, killing, querying and waiting for processes. Only the very basic functions are platform specific and the others are based on the abstraction layer that they provide.

CMake and the Filesystem

Thu, 27 Nov 2014 00:00:00 +0000

Filesystem

I have always been a bit confused when working with cmake’s file functions and the logic behind paths (sometimes they are found sometimes they are not…) For ease of use I reimplemented a own path managing system which behaves very similar to powershell and bash (see ss64.com) it is based around a global path stack and path qualification. All of my functions which work with paths use this system.

CTest and TextExplorer

Sat, 22 Nov 2014 00:00:00 +0000

Motivation

I have long searched for an extension in VisualStudio which allows you to control kitware’s CTests via the Test Explorer. Since no such thing existed I have developed a workable proof of concept myself :D.

This software is currently not in its finished state, It still needs polishing because it can be slow and is not well tested. However it works so if you want to give it a ride – go ahead. Feedback is welcome. But even more welcome would be if you chose to work on it and make it better.

Renameable Namespaces using the Preprocessor

Tue, 14 Oct 2014 00:00:00 +0000

Motivation

If you are starting to work on a library and do not know exactly how your namespaces are going end up these macro helper are for you. I have written helpers that simplify using namespaces and lets you build up your namespaces with preprocessor defines. This allows you to quickly rename your namespaces which in turn makes it alot more flexible. You can find the code on github. It is licensed under the MIT license.

Alternative `typedef` Syntax

Mon, 13 Oct 2014 00:00:00 +0000

Disclaimer: This post will be more interesting to you if you work with the preprocessor.

Here you can find a preprocessor only solution for changing the typedef syntax from typedef int number_type; to int typedef_as number_type; – an alternative typedef Syntax.

If your wondering where this might be useful let me tell you why I needed it: I was working on a preprocessor macro which defines a property – a field, a getter and a setter. The easiest syntax I was able to achieve was the following: typedef int property(MyValue) which expanded into something similar to this:

Dynamic Object in C++

Wed, 08 Oct 2014 00:00:00 +0000

You can find my implementation at https://github.com/toeb/cppdynamic it is licensed under the MIT license. I’d be happy for feedback and or optimizations :) Dynamic object are useful, especially in rapid prototyping, non-performance critical situations, and situations in which data/functions -bags are needed (non schema specific data). Also when serializing and deserializing dynamic objects can be a very valuable asset.

Dynamic programming languages inherently support this. e.g.

var obj = {};
obj.a = 'asd';
obj.b = {};
obj.b.c = 3;
obj.d = function(i,j){ return i+j;}

C# Also supports dynamic objects utilizing the dynamic keyword:

Useful extensions for CMake

Fri, 05 Sep 2014 00:00:00 +0000

When using cmake for more than just simple projects it is lacking in various aspects. Some list and string functions are missing. Interaction with command line applications and the file system are harder than they need to be. Especially however using structured data (maps and objects) and more complex funtional programming is not easy at all. So a couple of months ago I started implementing some extensions for object oriented programming 1 2. I which I continued to refine and which are the basis for my pure cmake package manager. They have now reached a level which I am confident enough in to describe in another post which I will try to distribute around the internet a bit so I can see if others find this useful as well.

dynamically calling `any` thing in C++

Tue, 15 Jul 2014 00:00:00 +0000

Extending upon boost’s any class which stores a type and a void ptr to any type of value, I created a callable version were you can assign any function, lambda, memberfunction etc. to the any and call it dynamically. This is a basic and important step for runtime reflection which I’m currently working on. Tell me if you like what I did and if you have any improvements.

You can look at the running example at ideone

`is_callable` type trait

Sat, 12 Jul 2014 00:00:00 +0000

I’ve developed a type_trait for checking if a type is callable, ie has defined a single operator(). Also on ideone

Tell me if you like it or if you know of a better version :D

/// function traits for member functions 
// gives you the class_type, return_type and arguments tuple for any member function (const and not const)
 template<typename T>
 struct func_traits{
 static const bool is_const_call = false;
 typedef void class_type;
 typedef void return_type;
 typedef void args_tuple;
 };
 // specialization for non const call member functions
 template < typename TClass ,typename TRet, typename ... TArgs>
 struct func_traits<TRet(TClass::*)(TArgs...)>
 {
 static const bool is_const_call = false;
 typedef TClass class_type;
 typedef TRet return_type;
 typedef std::tuple<TArgs...> args_tuple;
 };
 // specialization for const call member function
 template < typename TClass, typename TRet, typename ... TArgs>
 struct func_traits<TRet(TClass::*)(TArgs...)const>
 {
 static const bool is_const_call = true;
 typedef TClass class_type;
 typedef TRet return_type;
 typedef std::tuple<TArgs...> args_tuple;
 };

// checks wether a single call operator exists by sfinae ideom
 template<typename T>
 struct is_callable{

 private:
 // if the argument type is deducable this function is used
 template<typename TX = T>
 static char check(typename func_traits<decltype(&TX::operator())>::class_type);
 // else this function is used
 static double check(...);
 static T t;
 // if first function is used the call operator exists and the size is sizeof(char) instead of sizeof(double)
 enum{ _value = sizeof(check(t)) == sizeof(char) };
 public:
 const static bool value = _value;
 };

int main() {
 // B is a functor class, A not callable
 class B{ public:void operator()(int i)const{} };
 class A{};
 // this order works in MSVC 2013
 static_assert(is_callable<B>::value == true, "should be true");
 static_assert(is_callable<A>::value == false, "should be false");
 // 
 return 0;
}

Some Sources I queried when developing:

cmakepp: Reading and Writing JSON

Wed, 05 Mar 2014 00:00:00 +0000

While working on a package manager for CMake I came across the problem of finding a suitable format for my package descriptor files. First I thought about and tried using plain old CMake file that simply sets variables and can be included to access its contents. It was very quick and easy to implement. Hierarchical data structures however where hard to implement and a none standard format makes it harder to exchange data with a webservice/other programs. So I opted for using JSON as my import/export format. JSON is alot easier to parse than XML and is still ubiquitous in software developement so I cast aside XML (for now).

Object Oriented CMake: Next Iteration

Tue, 25 Feb 2014 00:00:00 +0000

I worked on my object oriented extensions for CMake and am on a much higher level of usability than before!

try it at https://github.com/toeb/oo-cmake

and as always: Feedback is most welcome

See the following object tutorial for ease of use: (for the current version look at the readme.md on github)

### using objects
### =============
# oo-cmake is very similar to javascript
# I actually used the javascript reference to figure out how things could be done :)
# oo-cmake is a pure object oriented language like javascript (only objects no types per se)
# oo-cmake is currently file based and relies heavily on dynamic functions to be upfron about it:
# oo-cmake is very slow (depending on what your doing)

## creating a object
## =================
obj_new(myobject)
# ${myobject} now is a reference to an object
obj_exists(${myobject} _exists)
assert(_exists)

## deleting a object
## =================
# oo-cmake does not contains automatic memory management
# you can however remove all objects by calling obj_cleanup 
# (a very crude way of garbage collection) I would suggest calling it at the end of cmake.
obj_new(object_to_delete)
obj_delete(${object_to_delete})
# object_to_delete still contains the same reference
# but the object does not exists anymore and the following returns false
obj_exists(${object_to_delete} _exists)
assert(NOT _exists)

## setting and setting property
## ==================
obj_new(myobject)
# call obj_set passing the object reference
# the propertyname 'key1' and the value 'val1'
# everything beyond 'key1' is saved (as a list)
obj_set(${myobject} key1 "val1")
#call obj_get passing the object refernce the result variable and
# the key which is to be gotten
obj_get(${myobject} theValue key1)
assert(theValue)
assert(${theValue} STREQUAL "val1")

## setting a function and calling it
## =================================
obj_new(obj)
obj_set(${obj} last_name "Becker")
obj_set(${obj} first_name "Tobias")
#obj_setfunction accepts any function (cmake command, string function, file function, unique function (see function tutorial))
# if you use a cmake function be sure that it will not be overwritten
# the safest way to add a function is to use obj_declarefunction
# you can either specify the key where it is to be stored or not
# if you do not specify it the name of the function is used
function(greet result)
 # in the function you have read access to all fields of the proeprty
 # as will as to 'this' which contains the reference to the object

 # this sets the variable ${result} in PARENT_SCOPE (returning values in cmake)
 set(${result} "Hello ${first_name} ${last_name}!" PARENT_SCOPE)

endfunction()
obj_setfunction(${obj} greet)
obj_callmember(${obj} greet res)
assert(res)
assert(${res} STREQUAL "Hello Tobias Becker!")
# alternatively you can also use obj_declarefunction
# this is actually the easiest way to define a function in code
obj_declarefunction(${obj} say_goodbye)
function(${say_goodbye} result)
 set(${result} "Goodbye ${first_name} ${last_name}!" PARENT_SCOPE)
endfunction()
obj_callmember(${obj} say_goodbye res)
assert(res)
assert(res STREQUAL "Goodbye Tobias Becker!")

## built in methods
## ================
# obj_new creates a object which automatically inherits Object
# Object contains some functions e.g. to_string, print, ...
# 
obj_new(obj)
obj_callmember(${obj} print)

# this prints all members
# ie
#{
# print: [function], 
# to_string: [function], 
# __ctor__: [object :object_Y3dVWkChKi], 
# __proto__: [object :object_AztQwnKoE7], 
#}

## constructors
## ============
# you can easily define a object type via constructor
function(MyObject)
 # declare a function on the prototype (which is accessible for all objects)
 # inheriting from MyObject
 obj_declarefunction(${__proto__} myMethod)
 function(${myMethod} result)
 set(${result} "myMethod: ${myValue}" PARENT_SCOPE)
 this_set(myNewProperty "this is a text ${myValue}")
 endfunction()

 # set a field for the object
 this_set(myValue "hello")
endfunction()

obj_new(obj MyObject)
# type of object will now be MyObject
obj_gettype(${obj} type)
assert(type)
assert(${type} STREQUAL MyObject)
# call
obj_callmember(${obj} myMethod res)
assert(res)
assert(${res} STREQUAL "myMethod: hello")
obj_set(${obj} myValue "othervalue")
obj_callmember(${obj} myMethod res)
assert(res)
assert(${res} STREQUAL "myMethod: othervalue")
obj_get(${obj} res myNewProperty)
assert(res)
assert(${res} STREQUAL "this is a text othervalue")

## functors
## ========

## binding a function
## ==================
# you can bind any function to an object without
# setting it as property
# causing the function to get access to 'this'
# and all defined properties
function(anyfunction)
 this_callmember(print)
endfunction()
obj_new(obj)
obj_bindcall(${obj} anyfunction)
## print the object
# alternatively you can bind the function to the object
obj_bind(boundfu ${obj} anyfunction)
call_function(${boundfu})
# prints the object
# alternatively you can bind and import then function
# beware that you might overwrite a defined function if you append REDEFINE
# 
obj_bindimport(${obj} anyfunction myBoundFunc REDEFINE)
myBoundFunc()
# print the object

Objects and Maps in CMake

Sun, 16 Feb 2014 00:00:00 +0000

Get it at https://github.com/toeb/oo-cmake and tell me if you like it

For more complex build system features oo programming would be a major boon. So I took it upon myself to create a usable and tested oo-extension for cmake (in pure CMake) so I could continue developing and extending my plattform independent tooling support (cutil) .

It’s too bad that Kitware decided to use their own language (with very little high level language features) for their build system product because CMakes project generation capabilties are unparalleled . I can understand that it seemed like a good idea at first ( the CMake scripting Language is platform independent and easier to use than make or bash or cmd also it was not intended to do complicated things). I however strongly believe that building a programm should be as easy as possible and therefore a high level language should have been used. CMake’s creators Bill Hoffman and Kenneth Martin have said that they would have done this differently if they had to do it again (http://www.aosabook.org/en/cmake.html)

Normalized Attribute Names in Angular

Tue, 14 Jan 2014 00:00:00 +0000

I have been doing some hard directive/ html markup work and I came across a problem where I needed the normalized html tag attribute names. (I was trying to create a html element but needed access to the normalized names without turning it into a directive)

Angular.js normalizes names like “test-name” and “data-test-name” to “testName”. So I went ahead and extracted and wrapped the functions needed into the following function:

Enabling MVC5 intellisense in a ClassLibrary Project

Sun, 05 Jan 2014 00:00:00 +0000

I’ve been searching and searching the internet for someone, somewhere who might know how to enable correct IntelliSense for cshtml (MVC 5.0) in VS2013 when developing in a ClassLibrary type project.

This is the problem I was encountering:

Missing Intellisense

It’s all thanks to Mohammad Chehab, who was also stumped for a while (probably not as long as me), that I was able to find the solution. His blog post explains that one must change the output path for the class library to bin/ (instead of bin/) for Intellisense to work.

Typescript in V2013

Wed, 18 Dec 2013 00:00:00 +0000

I know its a little obscure, but I recently needed to find out how to enable Typescript in a Visual Studio 2013 Class Library project, because per default this is not enabled. (probably a bug)

Vanilla way of enabling TypeScript:

Create a “Class Library” project Add a Typescript file (.ts) This is were the bug occurs, normally the TypeScript file should compile on save. However it does not. So after searching around and looking at the csproj file and comparing it to a MvcApplication csproj file I found out what the problem is:

A Fluent Way of Exception Handling

Mon, 09 Dec 2013 00:00:00 +0000

While doing some filesystem work I encountered alot of AccessViolationExceptions because a file is being opened to write multiple times. Even after closing the file explicitly a short timeframe exists in which the file could not be opened again. The simplest approach for me was to retry openening the file until it worked. To allow a more easy and more general way to handle exceptions I developed a small extensible try-repeat-framework which allows me to configure waiting and repeating strategies and also to only react to specific exceptions. I have written it with a fluent interface which allows easy usage:

Parsing Web Asset Files

Wed, 04 Dec 2013 00:00:00 +0000

To parse versioned web asset filenames ala jquery-1.4.min.js I wrote a simple class

/// <summary>
/// simple class for describing a file library like 
/// jquery-1.4.min.js
/// bootstrap.min.css
/// libname-1.0.0.0.tag1.tag2.tag3.extension
/// ... etc
/// contains methods for parsing these kind of filenames
/// </summary>
public class FileLib
{
 /// <summary>
 /// regular expression for parsing the filename
 /// </summary>
 public static readonly string libRegex = @"((?<libname>[^.-]*)-?)((?<major>d+))?(.(?<minor>d+)(.(?<revision>d+)(.(?<build>d+))?)?)?(.(?<tags>.+))*";
 /// <summary>
 /// parses a path as a lib
 /// </summary>
 /// <param name="path"></param>
 /// <returns></returns>
 public static FileLib ParsePath(string path)
 {
 var filename = Path.GetFileName(path);
 return Parse(filename);
 }
 /// <summary>
 /// parses a filename as a file lib 
 /// </summary>
 /// <param name="filename"></param>
 /// <returns></returns>
 public static FileLib Parse(string filename)
 {
 var match = Regex.Match(filename, libRegex);
 match.NextMatch();
 var lib = match.Groups["libname"].Value ?? "";
 var major = match.Groups["major"].Value ?? "";
 var minor = match.Groups["minor"].Value ?? "";
 var revision = match.Groups["revision"].Value ?? "";
 var build = match.Groups["build"].Value ?? "";
 var tags = match.Groups["tags"].Value.Split('.');
 var extension = tags.LastOrDefault() ?? "";
 tags = tags.Reverse().Skip(1).Reverse().ToArray();
 var result = new FileLib()
 {
 Extension = extension,
 LibName = lib,
 Major = major,
 Minor = minor,
 Revision = revision,
 Build = build,
 Tags = tags

 };
 return result;
 }
 /// <summary>
 /// Major version number
 /// </summary>
 public string Major { get; set; }
 /// <summary>
 /// Minor version number
 /// </summary>
 public string Minor { get; set; }
 /// <summary>
 /// Revision Number
 /// </summary>
 public string Revision { get; set; }

 /// <summary>
 /// Build number
 /// </summary>
 public string Build { get; set; }

 /// <summary>
 /// Creates a version object for the Filelib. returns null if this is not possible
 /// </summary>
 /// <returns></returns>
 public Version GetVersion()
 {

 Version parsedVersion = null;
 try
 {
 var version = Major + "." + Minor + "." + Revision + "." + Build;
 while (version.EndsWith(".")) version = version.Substring(0, version.Length - 1);
 if (version == "") return parsedVersion;
 parsedVersion = new Version(version);
 }
 catch (Exception exception) { }
 return parsedVersion;

 }
 /// <summary>
 /// the name of the lib
 /// </summary>
 public string LibName { get; set; }
 /// <summary>
 /// the tags of the lib. e.g. min, intellisense, etc
 /// </summary>
 public IEnumerable<string> Tags { get; set; }
 /// <summary>
 /// the extension of the lib
 /// </summary>
 public string Extension { get; set; }
}