Oleksandr Manenko's Blog

The principle of type substitution

Sun, 24 Mar 2024 00:00:00 +0000

Type substitution (or Liskov Substitution Principle in object-oriented contexts) allows an object of a certain type (supertype, superclass) to be replaced with an object of another type (subtype, subclass).

Let’s clarify the difference between subclass and subtype (and their super- counterparts) first. They are closely related, but stem from different concepts: inheritance and type compatibility.

Subtype vs. Subclass

Subclass is a class that inherits from another class, known as its superclass. A subclass inherits methods and properties (behavior and state) from the superclass and can add new methods and properties or override existing ones.

Subtype is a broader concept that refers to a type that satisfies the contract or interface of another type, known as its supertype. A subtype guarantees that it can be used in any context where its supertype is expected, adhering to the Liskov Substitution Principle (LSP). This relationship is not limited to classes and inheritance but also applies to interfaces, traits, and other type constructs.

Supertype vs. Superclass

Superclass is the class from which a subclass inherits. It’s a specific entity in class-based OOP that provides a blueprint for creating subclasses.

Supertype is a type that is generalized or abstracted from its subtypes. A supertype defines a contract (set of operations, methods, properties) that all its subtypes must satisfy. The subtype-supertype relationship can be determined by inheritance in OOP, but it can also arise from other type relationships, such as implementing an interface (Java) or conforming to a protocol (Clojure).

Type substitution

The key aspect of this concept is that the substituting object (the subtype instance) must be able to perform all the duties that the original object (the supertype instance) could perform, without requiring any changes to the external code that uses the object.

In order to achieve this level of compatibility, the following rules must apply:

The subtype must implement all the methods and properties that the supertype defines.
The subtype must not alter the expected behavior of the supertype in a way that could break the client code: preconditions, postconditions, and invariants must remain the same. For example, a subtype must not throw exceptions not expected from the supertype methods.

Java example

Java supports classical inheritance, making it straightforward to demonstrate subtyping.

abstract class Animal {
    abstract void makeSound() throws AnimalSoundException;
}

class AnimalSoundException extends Exception {
    public AnimalSoundException(String message) {
        super(message);
    }
}

class Dog extends Animal {
    @Override
    void makeSound() throws AnimalSoundException {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() throws AnimalSoundException {
        System.out.println("Meow!");
    }
}

class Rhino extends Animal {
    @Override
    void makeSound() throws AnimalSoundException {
        throw RuntimeException("Rhinos are silent and deadly!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = new Animal[]{new Dog(), new Cat()};
        for (Animal animal : animals) {
            try {
                animal.makeSound();
            } catch (AnimalSoundException e) {
                System.err.println("Error occurred: " + e.getMessage());
            }
        }
    }
}

Here, Dog, Cat, and Rhino have the same method makeSound as their supertype. However, only Dog and Cat adhere to LSP. Rhino violates the behavior of its supertype by throwing a RuntimeException and breaks the logic used by the client code which process instances of Animal-compatible types.

Python example

We could have used inheritance for Python as well but let’s demonstrate subtyping via different means: duck typing.

class AnimalSoundException(Exception):
    pass

class Dog:
    def make_sound(self):
        print("Woof!")

class Cat:
    def make_sound(self):
        print("Meow!")

class Rhino:
    def make_sound(self):
        raise RuntimeError("Rhinos are silent!")

def let_it_speak(animal):
    try:
        animal.make_sound()
    except AnimalSoundException as e:
        print(f"Error occurred: {str(e)}")

animals = [Dog(), Cat(), Rhino()]
for animal in animals:
    let_it_speak(animal)

Rhino violates the supertype’s behavior even though it commits to the same interface.

Variance

Variance is a type system concept that describes how the subtyping relationship between more complex types relates to the subtyping relationship between their component types. It’s mostly relevant in the context of generic types. Variance determines whether a generic type with a certain component type (like List<String>) can be considered a subtype or supertype of the same generic type with a different component type (like List<Object>). There are three main kinds of variance: covariance, contravariance, and invariance.

Covariance

Covariance allows for type substitution in a same direction. This means that if type A is a subtype of type B, then Container<A> is considered a subtype of Container<B>.

Covariance is applied in contexts where it is safe to read items from a container, but not to write items into it, because every item read out of a Container<A> is guaranteed to be at least an instance of B.

Consider a system where we need to read or extract information from a collection of objects. With covariance, we can use a collection of a more specific type where a collection of a more general type is expected. This is particularly useful when dealing with read-only operations where the type safety of write operations is not a concern.

Let’s use Java for this example, focusing on a scenario involving a collection of messages and the task of reading these messages.

First, we define message classes:

abstract class Message {
    abstract String getInfo();
}

class TextMessage extends Message {
    private String content;

    TextMessage(String content) {
        this.content = content;
    }

    @Override
    String getInfo() {
        return "TextMessage: " + content;
    }
}

class ImageMessage extends Message {
    private String imageUrl;

    ImageMessage(String imageUrl) {
        this.imageUrl = imageUrl;
    }

    @Override
    String getInfo() {
        return "ImageMessage with URL: " + imageUrl;
    }
}

Next, we define a MessageReader interface with a covariant generic type:

interface MessageReader<T extends Message> {
    T readMessage();
}

Suppose we want a reader that specifically reads TextMessage objects from a source. We’ll create a TextMessageReader:

class TextMessageReader implements MessageReader<TextMessage> {
    @Override
    public TextMessage readMessage() {
        return new TextMessage("Hello from TextMessageReader");
    }
}

Finally, to demonstrate covariance, we’ll use a method that expects a MessageReader<Message>, but we’ll pass it a MessageReader<TextMessage> thanks to covariance:

public class MessageReaderDemo {
    // A method that expects a reader capable of reading messages.
    public static void displayMessageInfo(MessageReader<? extends Message> reader) {
        Message message = reader.readMessage();
        System.out.println(message.getInfo());
    }

    public static void main(String[] args) {
        // Despite expecting a MessageReader<Message>, we can pass a
        // MessageReader<TextMessage> thanks to covariance.
        TextMessageReader textReader = new TextMessageReader();
        displayMessageInfo(textReader);
    }
}

In this example, displayMessageInfo method is designed to work with a MessageReader that can read any Message. Thanks to covariance (MessageReader<? extends Message>), we can pass it a TextMessageReader, which is a MessageReader specialized for TextMessage objects. This is safe because the method only reads messages from the reader and doesn’t attempt to write or modify them, ensuring type safety.

Covariance allows us to substitute a generic type with a subtype in situations where it’s safe to do so, typically in read-only contexts. In our case, a MessageReader specialized for a subtype (TextMessage) can be used wherever a MessageReader for the supertype (Message) is expected.

Contravariance

Contravariance allows for type substitution in an opposite direction. This means that if type A is a subtype of type B, then Container<B> is considered a subtype of Container<A>.

Contravariance is useful when dealing with types of functions (or more generally, producers and consumers of data). In a contravariant scenario, we can substitute a type with one of its supertypes. This is the opposite of covariance, where we can substitute a type with one of its subtypes.

Consider a function as a box that does something with input. If you have a function that expects a specific type of input (say, an Animal), you can safely replace it with a function that works with a more general input (say, a LivingCreature, of which Animal is a subtype).

Why is this safe? Because anywhere the original function was used, it was expected to handle an Animal. The new function can handle not just Animal but any LivingCreature, making it more flexible without breaking the original contract.

Imagine we have a system that processes messages, and we have a function type that handles these messages:

interface MessageHandler<T> {
    void handle(T message);
}

Let’s reuse Message and TextMessage types from the previous example. Then TextMessageHandler can be defined as follows:

class TextMessageHandler implements MessageHandler<TextMessage> {
    @Override
    public void handle(TextMessage message) {
        System.out.println("Handling text message: " + message.getContent());
    }
}

If MessageHandler were contravariant, you could use a MessageHandler<Message> wherever a MessageHandler<TextMessage> is expected. This means you could substitute a handler that is capable of dealing with all kinds of messages, not just text messages, which could look like this:

class GenericMessageHandler implements MessageHandler<Message> {
    @Override
    public void handle(Message message) {
        System.out.println("Handling a message: " + message.getInfo());
    }
}

This substitution is safe because the GenericMessageHandler can handle everything that TextMessageHandler can (since TextMessage is a subtype of Message), plus possibly more:

class MessageProcessor {
    // Process a list of messages with a handler
    // that can handle a supertype of those messages
    public static void processMessages(List<? extends Message> messages, MessageHandler<? super Message> handler) {
        for (Message message : messages) {
            handler.handle(message);
        }
    }

    public static void main(String[] args) {
        List<Message> messages = List.of(new TextMessage("Hello, World!"), new ImageMessage("http://example.com/omnomnom.jpg"));

        // Using the generic handler to process a mixed list of messages
        GenericMessageHandler genericHandler = new GenericMessageHandler();
        processMessages(messages, genericHandler);
    }
}

The principle here is that it’s safe to write (or in this case, handle) something more general in a place that expects something more specific. Contravariance is applicable in situations where data flows into a component (like function arguments).

Invariance

Invariance means there is no subtype relationship between different instantiations of the same generic type, regardless of their component types' relationship. Neither Container<A> nor Container<B> is considered a subtype of the other, even if A is a subtype of B. Both reading from and writing to an invariant container are type-safe, but this comes at the cost of flexibility.

Conclusion

Type substitution deals with how objects of different types can be used interchangeably without breaking the functionality of a program. It can be implemented through various mechanisms, such as inheritance, interfaces, generic, or duck typing, depending on the programming language.

When using generics, type substition becomes somewhat more complicated and determines its rules via a concept called variance:

Covariance allows substituting a type with its subtype, ideal for read-only scenarios.
Contravariance permits a type to be replaced with its supertype, suitable for write operations.
Invariance disallows substituting a generic type with its subtypes or supertypes.

How to use Rust memory allocator from C

Tue, 19 Mar 2024 00:00:00 +0000

The Rust allocator API requires a Layout struct to be passed into each of its functions. For example, to reallocate or free memory, you need to pass the pointer to the existing memory block and the layout used during its allocation.

This is a problem when interacting with C API which does not provide any means of storing additional allocation data.

The Cassandra C++ driver’s memory allocation functions is the example of such API, e.g.

unsafe extern "C" fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void

See? The memory reallocation function has the same signature as realloc from the standard C library and takes a pointer and the new size of the block.

Now compare this to the Rust memory allocation API:

unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8

This function has one additional parameter: the layout, I was talking about earlier. This must be the same layout used during the memory allocation.

And here comes the problem: we have no information about the layout in the C API and thus cannot pass it to Rust.

Oh, well, back to the old good memory tricks we used to use in C in the old days.

We need to store the layout used to allocate a memory block in the block itself, i.e. we need to allocate extra bytes, write the layout at the beginning of the block, and return the pointer to the first byte that follows the layout data. For example, when the driver requests 60 bytes of memory we allocate the memory block as follows:


                     requested amount of bytes (60)
                                    |
   size_of::<usize> bytes (8)       |
                |                   |
                v                   v
             +----+----------------------------------+
     +------>| 68 |0000000000000000000000000000000000|
     |       +----^----------------------------------+
block size        |
                  |
   pointer we return to the caller

Then, for Rust realloc and dealloc functions, we take the pointer, subtract the size of the allocation information, read the size of the block and reconstruct the layout structure. We don’t need to store the alignment, as we always use the same alignment (C API does not provide alignment parameters at all anyway).

The implementation could be found here.

Нова країна

Mon, 05 Feb 2024 00:00:00 +0000

Ця історія почалася десять років тому, коли я вперше інвестував у біткоїн. Я був програмістом, що був сфокусований на високих технологіях, але завжди мріяв про великі зміни у світі. Коли ціна біткоїна досягла небувалих висот, я зрозумів: це мій шанс.

Продавши все що мав, я отримав неймовірну суму грошей. Втім, замість того щоб інвестувати їх у традиційні активи або витрачати на розкоші, я вирішив реалізувати свою давню мрію — створити ідеальне суспільство.

Далі я вирушив на пошуки потрібного місця і знайшов маленький, майже непомітний острів біля екватора. Він був гарним та майже забутий цим світом. Мені навіть довелося найняти приватного детектива, щоб знайти власника.

Власником виявилася людина, що на той момент жила в Парагваї, та мала свої, особливі стосунки із законом. Цей чоловік як раз сидів у вʼязниці під велику заставу, то ж було нескладно вмовити його передати мені острів в обмін на кругленьку суму легальних грошей.

Купивши острів, я витратив частину коштів на розвиток інфраструктури та встановив відновлювальні джерел енергії. Ми будували житлові будинки, школи та лікарні, використовуючи екологічно чисті матеріали та технології.

Втім моя мета була не просто створити ще одну країну. Я мріяв побудувати анархічне суспільство, засноване на принципах свободи та рівності. Люди самі вирішували як їм жити, без централізованого уряду, який би нав’язував свої правила.

Економіка була заснована на принципах взаємодопомоги та взаємного кредитування. Використовуючи блокчейн, ми створили власну цифрову валюту для спрощення обміну товарами та послугами, а також цифрову систему прийняття рішень, щоб важливі питанння вирішувалися через голосування всіма членами спільноти.

Ще через десять років наш острів перетворився на справжній рай. Місцеві, які спочатку ставилися до мене насторожено, тепер називали мене Падре через те, що вважали мене батьком нової нації. А ще тому, що час почав забирати своє, додавши мені сивого волосся.

Ми створили суспільство, де немає місця злочинності та заздрості, а відносини між людьми будуються на взаємній повазі та допомозі. Все це стало можливим завдяки вірі в ідею, що світ можна змінити на краще та запасу біткоїну, вартість якого стрімко вирісла, перш ніж знову впасти.

А потім я прокинувся і згадав, що немає в мене стільки біткоїну. Блять.

Sparse sets

Sun, 23 May 2021 00:00:00 +0000

A sparse set is a simple data structure that has a few interesting properties:

O(1) to add an item.
O(1) to remove an item.
O(1) to lookup an item.
O(1) to clear the set.
O(n) to iterate over the set.
A set does not require its internal items storage to be initialised upon creation (!).

Sparse sets are commonly used to implement Entity Component System architectural pattern. I plan to cover ECS in one of my future posts but for now let’s try to understand and implement sparse sets.

Overview

Sparse sets use two integer arrays internally: dense and sparse. The former is a packed array that stores the set’s items (integers) in the insertion order. The latter is an array that can have holes (hence the name – sparse) and it maps the set’s items to their indices in dense. The set also keeps track of how many items it has. We call it N.

Sparse sets could be implemented as growable, i.e. being able to reallocate the memory they use but I will use non-growable version in this post for simplicity. This means a user has to specify the size of the set upon creation.

/** An item stored in a sparse set. */
typedef uint32_t rho_ss_id;

/** Maximum possible value of the rho_ss_id. */
static const rho_ss_id rho_ss_id_max = UINT32_MAX - 1;

/** The sparse set. */
struct rho_ss {
    rho_ss_id *sparse;  /**< Sparse array used to speed-optimise the set.     */
    rho_ss_id *dense;   /**< Dense array that stores the set's items.         */
    rho_ss_id  n;       /**< Number of items in the dense array.              */
    rho_ss_id  max;     /**< Maximum allowed item ID.                         */
};

An empty set

We start with an empty set that can have up to max items. The next picture demonstrates the sparse set that can hold up to ten items.

N is zero, dense and sparse are allocated but not initialised.

struct rho_ss rho_ss_alloc( rho_ss_id max_id )
{
    assert( max_id > 0 && max_id <= rho_ss_id_max );

    size_t        array_size = sizeof( rho_ss_id ) * ( max_id + 1 );
    struct rho_ss ss         = { 0 };

    ss.dense  = malloc( array_size );
    ss.sparse = malloc( array_size );

    if ( !ss.dense || !ss.sparse ) {
        free( ss.dense );
        free( ss.sparse );

        ss.dense  = NULL;
        ss.sparse = NULL;
    } else {
        ss.max = max_id;
    }

    return ss;
}

Adding a first item

Let’s add 4 as a first item to the set.

First, we add the item to the dense at index 0 (this is the current value of N). Then we write N to the sparse array at index 4. Now both slots in the dense and sparse arrays point to each other. Lastly, we increase N by one.

Adding a second item

Let’s add 6 as a second item.

The steps are the same. We put 6 to the next free slot of the dense array, write N to the sparse at index 6, and increase N by one.

The sparse array has holes, while the dense array items are placed next to each other.

Adding a third item

Now we add 0 as a third item.

There is nothing new here. The item we added is 0 so we put its dense index (which is 2) to sparse at index 0.

And this is how we can implement it:

void rho_ss_add( struct rho_ss *ss, rho_ss_id id )
{
    assert( ss );
    assert( id <= ss->max );

    if ( rho_ss_has( ss, id ) ) {
        return;
    }

    ss->dense[ss->n] = id;
    ss->sparse[id]   = ss->n;

    ++ss->n;
}

The rho_ss_has function checks if the given item is in the sparse set. We implement it in the next section.

Checking whether an item is in the set

Let’s test if 6 is in the set. To do so we go to the sparse array and check its value at index 6. The value is 1. Now we use this value as an index in the dense array. The dense has value 6 at this index, which means 'yes, the set contains item six'.

Now let’s check if 9 is in the set. We go to the sparse array and check its value at index 9. The value is garbage (we haven’t initialised the memory, remember?) and can be anything, let’s say it is X.

If X >= N then X is out of bounds index for the dense array and 9 is not in the set.

Suppose X is less than N. In our case it should be either of 0, 1, or 2 because N is 3. We check if the dense array’s value at index X is 9. It is not and it cannot be, so the answer is 'no, the set does not contain item nine'.

Now we can implement the operation:

bool rho_ss_has( struct rho_ss *ss, rho_ss_id id )
{
    assert( ss );
    assert( id <= ss->max );

    rho_ss_id dense_index = ss->sparse[id];

    return dense_index < ss->n && ss->dense[dense_index] == id;
}

Removing an item

Let’s remove 6 from the set.

First, we replace 6 with the last item from the dense array, which is 0. Then we have to update the spare array at index 0 with the new index of 0 in the dense array, which is 1. And then reduce N by one.

In other words to remove an item from the set, we replace it with the last item in the dense array and update the corresponding sparse array’s slot to point to the new location.

The implementation is as follows:

void rho_ss_remove( struct rho_ss *ss, rho_ss_id id )
{
    assert( ss );
    assert( id <= ss->max );

    if ( rho_ss_has( ss, id ) ) {
        --ss->n;
        rho_ss_id dense_index  = ss->sparse[id];
        rho_ss_id item         = ss->dense[ss->n];
        ss->dense[dense_index] = item;
        ss->sparse[item]       = dense_index;
    }
}

Iterating over the set

This one is super simple. You just iterate over the dense array.

Like this (highlighted lines):

struct rho_ss ss = rho_ss_alloc( 10 );
rho_ss_add( &ss, 4 );
rho_ss_add( &ss, 6 );
rho_ss_add( &ss, 0 );

for ( rho_ss_id i = 0; i < ss.n; ++i ) {
    printf( "%d ", ss.dense[i] );
}
printf( "%s", "\n" );

rho_ss_free( &ss );

Clearing the set

Just set N to zero:

void rho_ss_clear( struct rho_ss *ss )
{
    assert( ss );

    ss->n = 0;
}

Like I said before, most of the sparse set operations are super fast.

What’s next?

You could play with my implementation of the sparse set or (and this is preffered way) implement it on your own.

How to make Unreal Engine work correctly with CLion?

Tue, 18 May 2021 00:00:00 +0000

Unreal Engine by Epic Games is a masterpiece. THE Game Engine. It is super powerful and convenient to use.

There is a problem, though.

Epic Games developers use Windows and Visual Studio to develop the engine and don’t invest the same amount of time to other development tools.

Unreal Engine supports the following source code editors:

Xcode
Visual Studio
Visual Studio Code
CLion

Visual Studio and Visual Studio Code are the first-class citizens and work well with UE4. More importantly, Visual Studio Code is cross-platform so you can just use that. It is okay text editor.

Xcode and CLion on the other hand are next to impossible to use with the project files generated by UE4.

JetBrains are good in making IDEs and CLion is a perfect C++ IDE. THE perfect engine needs THE perfect IDE so let’s marry them.

The problem

The current version of UE4 (4.26) generates incorrect CMake project files. The bug exists for a long time but has not been fixed yet in any official build of the engine.

The problem with the files it generates is that they don’t have a few important project-wide macro definitions. For example, each project has a ${PROJECT_NAME}_API macro. The macro is used for exporting/importing C++ functions and classes, which is required on Windows, where it expands to __declspec(dllimport) or __declspec(dllexport) storage-class attributes. The symbol is not defined which makes C++ definitions incorrect and CLion yells at you about syntatic errors in the code. This also breaks autocomplete.

Other examples are GENERATED_BODY, UCLASS, UPROPERTY and many more U4 macros which are not properly defined for CMake-based projects because some of the symbols they depend on are not defined either.

The solution

If you search the Internet hard enough, you can find a patch that fixes the problem.

So go and grab the patch. Then open your terminal, go to the engine source code (for macOS it should be /Users/Shared/Epic Games/UE_4.26). Then apply the patch:

$ patch -p1 < /path/to/ue4_25-defines-fix.patch

Now, if you use zsh as I do, switch to bash temporarely and source a setup environment script for your platform, in my case macOS:

$ bash
bash-3.2$ source Engine/Build/BatchFiles/Mac/SetupEnvironment.sh -mono Engine/Build/BatchFiles/Mac

The next step is to build and install Unreal Build Tool:

bash-3.2$ xbuild Engine/Source/Programs/UnrealBuildTool/UnrealBuildTool.csproj

The command will spit a deprecation warning on you, then compile the tool and install it to the right place replacing the old one so that the Unreal Editor can pick it up.

Now you can generate CLion project and open the project in the IDE. It will take some time for it to load all symbols, though. Select ${PROJECT_NAME}Editor|Debug build target and build it each time you want to make your code changes available to the Unreal Editor.

What about other IDEs and editors that support CMake?

In this post I described how to generate correct CMake files. Once you have the files, you can import them into any IDE/editor that supports CMake and everything should work out of the box.

For example, here I have a project opened in Emacs:

Symbol navigation, autocomplete, documentation browser, and refactor work perfectly well.

Happy coding! :-)

Managing external dependencies with CMake

Sun, 30 Sep 2018 00:00:00 +0000

CMake is a de facto standard build tool for C++. There are those who love it, and there are those who hate it. The tool had a few problems in the past, but Modern CMake solved most of them and continued to evolve and add more and more features.

Watch Effective CMake talk by Daniel Pfeifer and Using Modern CMake Patterns to Enforce a Good Modular Design by Mathieu Ropert to get an idea and hints on modern CMake.

In this blog post, I describe the approach I use to manage external dependencies in C++ projects.

The dependencies have to have a valid CMake configuration, i.e. they have to export their targets as described in Daniel Pfeifer’s "Effective CMake" starting at 37:34, Henry Schreiner’s Modern CMake: Exporting and Installing, and It’s Time To Do CMake Right by Pablo Arias.

Typical project layout

Let’s review the layout of one of my C++ projects:

$ outpost-cpp git:(master) tree -L 2
.
├── build
├── cmake
│   ├── Catch.cmake
│   ├── CatchAddTests.cmake
│   └── ParseAndAddCatchTests.cmake
├── conker
│   ├── include
│   ├── src
│   └── CMakeLists.txt
├── extern
│   └── CMakeLists.txt
├── outpost
│   ├── assets
│   ├── include
│   ├── src
│   └── CMakeLists.txt
├── test
│   ├── src
│   └── CMakeLists.txt
├── CMakeLists.txt
└── Doxyfile

12 directories, 9 files

There are a few items in the root directory of the project:

Directory Purpose

Directory	Purpose
.	Project root with the root `CMakeLists.txt`
build	That’s where you do `cd build && cmake .. && make` to build the project
cmake	Consists of custom CMake modules
conker	A subproject for a library
extern	External dependencies
outpost	A subproject for a main application
test	A subproject for unit-tests

Project root with the root CMakeLists.txt

build

That’s where you do cd build && cmake .. && make to build the project

cmake

Consists of custom CMake modules

conker

A subproject for a library

extern

External dependencies

outpost

A subproject for a main application

test

A subproject for unit-tests

Describing dependencies

The extern/CMakeLists.txt file is a central repository for the dependencies. Make it available from the root CMakeLists.txt:

CMakeLists.txt

add_subdirectory(extern)

Let’s take a closer look at the dependencies file:

extern/CMakeLists.txt

cmake_minimum_required(VERSION 3.11 FATAL_ERROR)

include(FetchContent)

# ------------------------------------------------------------------------------
# A modern, C++-native, header-only, test framework for unit-tests,
# TDD and BDD - using C++11, C++14, C++17 and later
FetchContent_Declare(
  extern_catch2

  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
  GIT_TAG        v2.2.3)

FetchContent_GetProperties(extern_catch2)
if(NOT extern_catch2_POPULATED)
  FetchContent_Populate(extern_catch2)
  add_subdirectory(
    ${extern_catch2_SOURCE_DIR}
    ${extern_catch2_BINARY_DIR}
    EXCLUDE_FROM_ALL)
endif()

# ------------------------------------------------------------------------------
# A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and
# input http://www.glfw.org/
FetchContent_Declare(
  extern_glfw

  GIT_REPOSITORY https://github.com/glfw/glfw.git)

FetchContent_GetProperties(extern_glfw)
if(NOT extern_glfw_POPULATED)
  FetchContent_Populate(extern_glfw)
  add_subdirectory(
    ${extern_glfw_SOURCE_DIR}
    ${extern_glfw_BINARY_DIR}
    EXCLUDE_FROM_ALL)
endif()

# ------------------------------------------------------------------------------
# https://devblogs.nvidia.com/linking-opengl-server-side-rendering/
find_package(
  OpenGL     REQUIRED
  COMPONENTS OpenGL)

The script uses CMake’s FetchContent module which enables populating content at configure time. That’s how you describe a dependency:

extern/CMakeLists.txt

FetchContent_Declare(
  extern_catch2

  GIT_REPOSITORY https://github.com/catchorg/Catch2.git
  GIT_TAG        v2.2.3)

FetchContent_GetProperties(extern_catch2)
if(NOT extern_catch2_POPULATED)
  FetchContent_Populate(extern_catch2)
  add_subdirectory(
    ${extern_catch2_SOURCE_DIR}
    ${extern_catch2_BINARY_DIR}
    EXCLUDE_FROM_ALL)
endif()

In other words, you declare where and how to get the dependency first and then check if it is already available. If it is not avialable yet, then you fetch it and include into the build using the add_subdirectory command.

Importing dependencies in subprojects

FetchContent makes exported targets available to the build so that you can use them in target_link_libraries:

outpost/CMakeLists.txt

target_link_libraries(outpost
  conker
  glfw
  )

Here, I added the glfw as a public dependency to the outpost target.

Another example:

test/CMakeLists.txt

target_link_libraries(conker_tests
  PRIVATE Catch conker)

Hierarchical dependency management

There are few ways to organise dependency management.

Keep all dependencies in the same file

It’s good enough for simple projects that live in the same repository, and there are no plans to move subprojects outside of it. That’s what I described in the previous sections.

├── CMakeLists.txt
├── extern
│   └── CMakeLists.txt
├── subproject_a
│   └── CMakeLists.txt
├── subproject_b
│   └── CMakeLists.txt
└── subproject_c
      └── CMakeLists.txt

Each subproject describes its dependencies

In this case, you make subprojects independent by adding their own external/CMakeLists.txt. Then you can extract any of them from the source tree and build it without any further configuration if needed.

├── CMakeLists.txt
├── subproject_a
│   ├── extern
│   │   └── CMakeLists.txt
│   └── CMakeLists.txt
├── subproject_b
│   ├── extern
│   │   └── CMakeLists.txt
│   └── CMakeLists.txt
└── subproject_c
    ├── extern
    │   └── CMakeLists.txt
    └── CMakeLists.txt

Combination of the previous methods

You declare dependencies for each subproject in their own external/CMakeLists.txt. Then you declare (i.e. duplicate) dependencies on one level higher than the subprojects. This is how you override population of content specified anywhere lower in the project hierarchy.

├── CMakeLists.txt
├── extern
│   └── CMakeLists.txt
├── subproject_a
│   ├── extern
│   │   └── CMakeLists.txt
│   └── CMakeLists.txt
├── subproject_b
│   ├── extern
│   │   └── CMakeLists.txt
│   └── CMakeLists.txt
└── subproject_c
    ├── extern
    │   └── CMakeLists.txt
    └── CMakeLists.txt

The end

I hope this helps.

How to setup Emacs for Rust development

Wed, 03 Aug 2016 00:00:00 +0000

In this post I will show you how to setup Emacs for the Rust development. We will start with empty setup and then move iteratively adding new features. At the end of the process you should have something similar to the following screenshot:

Initial setup

Emacs loads it’s configuration from initialization file which can be ~/.emacs, ~/.emacs.el, or .emacs.d/init.el.

We will use .emacs.d/init.el file as configuration script. Let’s create it:

$ mkdir ~/.emacs.d
$ cd ~/.emacs.d
$ touch init.el
$ git init .

Here, we created initialization file as well as new git repository inside .emacs.d directory. Git step is optional and it has nothing to do with Emacs configuration. However, I strictly advise not to skip it, because putting your configuration directory under the source control allows you to have version tracking, rollbacks, backups (just create a new repository on http://bitbucket.com or similar resource and sync your local repository with the remote one).

Now, create ~/.emacs.d/.gitignore file with the following content:

~/.emacs.d/.gitignore

*~
places
\.recentf
\.smex-items
ido.last
projectile-bookmarks.eld
projectile.cache
auto-save-list
backups
elpa/
eshell

Commit your changes to the source control.

What to put into init.el file

You can put all your configuration inside Emacs initialization file. However this is not a best idea. As we know from software development it is much better to group similar things into modules/packages/you-name-it to simplify future reuse, changes, etc.

We will use init.el file as an entry point that loads all other scripts.

Open init.el file and add the following code to it:

~/.emacs.d/init.el

(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))

(provide 'init)

Here we tell Emacs that we will put all our custom scripts into ~/.emacs.d/lisp folder so that Emacs can find them when we use require function to load these scripts. You can read more about loading scripts in Emacs Lisp here.

Packages

Package is an Emacs Lisp program that provides additional features. You can read about Emacs packages here.

In fact all our scripts will be Emacs packages because this simplifies dependency management and has ultra-speed load time.

Add (require 'init-elpa) line to the ~/.emacs.d/init.el script. Now it should look like this:

~/.emacs.d/init.el

(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))

(require 'init-elpa)

(provide 'init)

This line will load ~/.emacs.d/lisp/init-elpa.el and all its dependencies.

Now create ~/.emacs.d/lisp/init-elpa.el file, open it for editing and put the following code in it:

~/.emacs.d/lisp/init-elpa.el

(require 'package)

(defun require-package (package)
  "Install given PACKAGE if it was not installed before."
  (if (package-installed-p package)
      t
    (progn
      (unless (assoc package package-archive-contents)
	(package-refresh-contents))
      (package-install package))))

(add-to-list 'package-archives
	     '("melpa" . "https://melpa.org/packages/"))

(package-initialize)

(provide 'init-elpa)

This package initializes Emacs package system, adds MELPA the list of available package archives and defines a function require-package that installs the given package if it was not installed before.

Exec path [OS X only]

The next step is specific to OS X, where an Emacs instance started from the GUI will have a different environment than a shell in a terminal window, because OS X does not run a shell during the login. Obviously this will lead to unexpected results when calling external utilities like make from Emacs.

So here we are going to solve this issue by using exec-path-from-shell package.

Add the line (require 'init-exec-path) after the last require in the ~/.emacs.d/init.el file:

~/.emacs.d/init.el

(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))

(require 'init-elpa)
(require 'init-exec-path)

(provide 'init)

In the future, when I say add require to the initialization file it means add it to the ~/.emacs.d/init.el file after the last require as in previous example.

Now open ~/.emacs.d/lisp/init-exec-path.el and fill it with the following code:

~/.emacs.d/lisp/init-exec-path.el

(require 'init-elpa)

(require-package 'exec-path-from-shell)
(when (memq window-system '(mac ns x))
  (exec-path-from-shell-initialize))

(provide 'init-exec-path)

First, we require 'init-elpa package we created before to use its require-package function.

Second, we execute exec-path-from-shell-initialize function only if this instance of Emacs is run under the OS X.

UI

Now it’s time to deal with default Emacs UI. Add (require 'init-ui) to Emacs initialization file, then open ~/.emacs.d/lisp/init-ui.el and add the following lines:

~/.emacs.d/lisp/init-ui.el

(require 'init-elpa)
(require-package 'atom-one-dark-theme)
(require-package 'golden-ratio)

(require 'golden-ratio)

(setq inhibit-startup-message t)
(menu-bar-mode -1)
(when (fboundp 'tool-bar-mode)
  (tool-bar-mode -1))
(when (fboundp 'scroll-bar-mode)
  (scroll-bar-mode -1))

(set-face-attribute 'default nil :height 140)
(setq-default line-spacing 0.4)

(setq
      x-select-enable-clipboard t
      x-select-enable-primary t
      save-interprogram-paste-before-kill t
      apropos-do-all t
      mouse-yank-at-point t)

(load-theme 'atom-one-dark t)

(blink-cursor-mode 0)
(setq-default cursor-type 'bar)
(set-cursor-color "#cccccc")
(setq ring-bell-function 'ignore)

(golden-ratio-mode 1)

(provide 'init-ui)

There is a little bit more code in this package than in the previous. It turns off menu bar, scroll bar, and tool bar, as well as standard welcome message. It installs and loads Atom One dark syntax theme.

Another important feature is Golden Ratio. It resizes Emacs windows automatically to make the window that has the focus to have perfect size for editing.

Editing

The next step is to make editing a little bit more convenient.

Add (require 'init-editing) to the initialization file, open ~/.emacs.d/lisp/init-editing.el script and add the following:

~/.emacs.d/lisp/init-editing.el

(require 'init-elpa)
(require 'saveplace)
(require-package 'rainbow-delimiters)
(require-package 'flycheck)

;; Highlights matching parenthesis
(show-paren-mode 1)

;; Highlight current line
(global-hl-line-mode 1)

;; Interactive search key bindings. By default, C-s runs
;; isearch-forward, so this swaps the bindings.
(global-set-key (kbd "C-s") 'isearch-forward-regexp)
(global-set-key (kbd "C-r") 'isearch-backward-regexp)
(global-set-key (kbd "C-M-s") 'isearch-forward)
(global-set-key (kbd "C-M-r") 'isearch-backward)

(define-key global-map (kbd "RET") 'newline-and-indent)

(add-hook 'after-init-hook #'global-flycheck-mode)

;; When you visit a file, point goes to the last place where it
;; was when you previously visited the same file.
;; http://www.emacswiki.org/emacs/SavePlace

(setq-default save-place t)
;; keep track of saved places in ~/.emacs.d/places
(setq save-place-file (concat user-emacs-directory "places"))

;; Emacs can automatically create backup files. This tells Emacs to
;; put all backups in ~/.emacs.d/backups. More info:
;; http://www.gnu.org/software/emacs/manual/html_node/elisp/Backup-Files.html
(setq backup-directory-alist `(("." . ,(concat user-emacs-directory
                                               "backups"))))
(setq auto-save-default nil)

(defun toggle-comment-on-line ()
  "Comment or uncomment current line."
  (interactive)
  (comment-or-uncomment-region (line-beginning-position) (line-end-position)))
(global-set-key (kbd "C-;") 'toggle-comment-on-line)

(add-hook 'prog-mode-hook #'rainbow-delimiters-mode)

(provide 'init-editing)

It is pretty good documented. Just go through it and read the source :)

Add (require 'init-navigation) to the initialization file and open ~/.emacs.d/lisp/init-navigation.el script.

We are going to install and configure the following packages:

Interactively Do Things or Ido mode. I advise you to read Introduction to Ido Mode.
ido-ubiquitous mode. This package replaces stock emacs completion with Ido completion wherever it is possible to do so without breaking things.
Smex. Built on top of Ido, it provides a convenient interface to your recently and most frequently used commands. And to all the other commands, too.
Recentf. Recentf is a minor mode that builds a list of recently opened files. This list is automatically saved across sessions on exiting Emacs - you can then access this list through a command or the menu.
Projectile. It provides easy project management and navigation. Please refer to the link I’ve provide for complete list of features.

And here is the code:

~/.emacs.d/lisp/init-navigation.el

(require 'init-elpa)
(require 'ido)
(require 'recentf)
(require-package 'ido-ubiquitous)
(require-package 'smex)
(require-package 'projectile)

(setq recentf-save-file (concat user-emacs-directory ".recentf"))
(recentf-mode 1)
(setq recentf-max-menu-items 40)

(ido-mode t)
(setq ido-enable-flex-matching t)
(setq ido-use-filename-at-point nil)
(setq ido-auto-merge-work-directories-length -1)
(setq ido-use-virtual-buffers t)

(ido-ubiquitous-mode 1)

;; Shows a list of buffers
(global-set-key (kbd "C-x C-b") 'ibuffer)

(setq smex-save-file (concat user-emacs-directory ".smex-items"))
(smex-initialize)
(global-set-key (kbd "M-x") 'smex)

(projectile-global-mode)

;; Enable move point from window to window using Shift and the arrow keys
(windmove-default-keybindings)

(provide 'init-navigation)

Miscellaneous

Here we will setup a few things to make Emacs to be more convenient to use.

Add (require 'init-miscellaneous) to the initialization file and open the ~/.emacs.d/lisp/init-miscellaneous.el for editing. Add the following lines:

~/.emacs.d/lisp/init-miscellaneous.el

;; Changes all yes/no questions to y/n type
(fset 'yes-or-no-p 'y-or-n-p)

;; No need for ~ files when editing
(setq create-lockfiles nil)

(provide 'init-miscellaneous)

It changes yes/no questions to y/n type so that you can just press y or n, instead of typing yes or no. Also this packages disables generation of Emacs lock files.

Text Completion

Emacs has very good text completion framework called company-mode. Let’s install and configure it.

Add (require 'init-company-mode) to the initialization file as usual, then open ~/.emacs.d/lisp/init-company-mode.el script and add these lines:

~/.emacs.d/lisp/init-company-mode.el

(require 'init-elpa)
(require-package 'company)
(require 'company)

(setq company-tooltip-align-annotations t)
(add-hook 'prog-mode-hook 'company-mode)

(provide 'init-company-mode)

Here, we enable company mode for all programming modes making it default autocompletion engine.

Now save everything and commit to the source control.

Rust Support

Please, make sure that you have Rust installed before continue.

Now here is the thing. We have to install third-party tools to make Rust autocompletion work.

Install Racer

Please, follow the Racer installation guideline to install it on your machine.

Install Rust sources

Clone the https://github.com/rust-lang/rust repository.

Configure Rust Support in Emacs

As usual, add (require 'init-rust) to the initialization file and add the following code to the ~/.emacs.d/lisp/init-rust.el package:

~/.emacs.d/lisp/init-rust.el

(require 'init-elpa)
(require-package 'company)
(require-package 'racer)
(require-package 'rust-mode)
(require-package 'flycheck)
(require-package 'flycheck-rust)

(require 'company)
(require 'racer)
(require 'rust-mode)
(require 'electric)
(require 'eldoc)
(require 'flycheck)
(require 'flycheck-rust)

(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
(add-hook 'rust-mode-hook  #'company-mode)
(add-hook 'rust-mode-hook  #'racer-mode)
(add-hook 'racer-mode-hook #'eldoc-mode)
(add-hook 'flycheck-mode-hook #'flycheck-rust-setup)
(add-hook 'rust-mode-hook
          '(lambda ()
	     (setq racer-cmd (concat (getenv "HOME") "/.rust-dev/racer/target/release/racer"))
	     (setq racer-rust-src-path (concat (getenv "HOME") "/.rust-dev/rust/src"))
             (local-set-key (kbd "TAB") #'company-indent-or-complete-common)
	     (electric-pair-mode 1)))

(provide 'init-rust)

This package installs the following dependencies:

Flycheck. This is a modern on-the-fly syntax checking extension.
flycheck-rust. It adds Rust syntax checking and linting to Flycheck.
rust-mode. This adds Rust syntax highlighting, etc.
racer. It allows Emacs to use Racer for Rust code completion and navigation.

Please, change the path to the racer executable (racer-cmd variable) and the path to the Rust sources (racer-rust-src-path variable) according to your local environment.

For example, I downloaded racer to the ~/.rust-dev/racer folder and Rust sources to the ~/.rust-dev/rust.

Save everything, commit to the source control, start Emacs. Wait until it finishes installing missing packages, then restart it.

Now you should have Rust syntax highlighting, autocomplete, and project navigation in your beloved Emacs.

You can find my Emacs config here.

That’s it.

GDM doesn't load included files from .Xresources in Arch Linux

Fri, 15 May 2015 00:00:00 +0000

I installed Arch Linux along with GNOME 3 yesterday. I have a git repository to keep all my settings the same across all devices.

This is how my .Xresources looks like:

#include "Xresources.d/xterm"
#include "Xresources.d/Xft"

I use different files for each application settings and #include them into the main .Xresources file. That’s works just fine.

However, it seems that GDM ignores all #include-s in .Xresources file. I didn’t have such issues in Fedora, so I assume this is Arch Linux specific thing.

After some investigation I found that /etc/gdm/Xsession has the following code:

if [ -f "$userresources" ]; then
    xrdb -nocpp -merge "$userresources"
fi

According to man xrdb:

-nocpp  This option indicates that xrdb should not run the  input  file
        through a preprocessor before loading it into properties.

It means, that cpp preprocessor doesn’t get called and that’s why included files were not loaded.

The fix is simple: just edit the /etc/gdm/Xsession file and remove -nocpp option from the command that loads .Xresources:

if [ -f "$userresources" ]; then
    xrdb -merge "$userresources"
fi

Maintainers decided to use -nocpp flag because of performance. It seems that calling the cpp preprocessor is quite expensive operation. Most of users don’t use #include, #define, etc. in their .Xresources file. By using -nocpp you can decrease startup time of your graphic environment.

Put UIDatePicker inside static UITableView

Fri, 19 Dec 2014 00:00:00 +0000

In the previous article we implemented input form using UITableView. Static table views provide a great help during iOS applications development: developer can visually create nice looking UIs. One of the common tasks here is to create UI for picking a date. Apple already provides UI element for this: UIDatePicker.

In this article we will embed UIDatePicker into the UITableViewCell inside static table view. User will be able to show/hide it by tapping on a label with date. Apple do this in their Reminders application.

Let’s reproduce this behavior.

Initial Setup

Create a single view application, remove default view from the Main.storyboard and add Table View Controller instead. And don’t forget to make it Initial View Controller. Remove ViewController.swift file as well.

Now, select table view and set it’s Content to Static Cells, Style to Grouped and uncheck Show Selection on Touch:

Set number of Sections to 3. First section should have one row, second section - 4 rows, third section - 2 rows. Select all rows and set their Selection property to None.

Rows' Setup

First row

Select first row and set its style to Basic. Double click on a label inside the cell and enter any text. I use "Write a letter to your future self". This is a text for reminder.

Second row

Select second row and set its style to Custom. Drag and drop one label and one switch on it. Place label close to the left edge of the row. Put switch close to the right edge.

Setup Auto Layout constraints for the switch:

Setup Auto Layout constraints for the label:

Double click on the label and set it’s text to "Remind me on a day". Set State of the switch to Off.

Third row

Select third row and set its style to the Right Detail. Double click on Title label and set it’s text to "Alarm".

Table view should have the following look right now:

Fourth row

Select fourth row and resize it:

Drag and drop date picker on it and setup Auto Layout (just use Reset to Suggested Constraints on it):

Fifth row

Select fifth row and set it’s style to Right Detail. Set it’s Accessory to Disclosure Indicator. Double click on Title label and set its text to "Repeat". Double click on Detail label and set its text to "Never".

Sixth row

Setup it in the same way as row #2. Set label text to "Remind me at a location".

Seventh row

Set its style to Basic. Set it’s Accessory to Disclosure Indicator. Double click on Title label and set its text to "Location".

This is how your table view should look like now:

I decided not to copy the whole UI look and feel of the Reminders application for simplicity.

Listen to DatePicker’s value changes

We want to update text of the Detail label of third row each time user changes value of the date picker.

Create a new Cocoa Touch Class named TableViewController and set its base class to UITableViewController. Remove all auto generated code inside newly created class:

import UIKit

public class TableViewController: UITableViewController {
}

Open storyboard and select table view controller on it. Go to Identity Inspector and set Class to TableViewController.

Create outlets for detail label and date picker using Ctrl+Drag in Assistant Editor.

@IBOutlet weak var txtDate: UILabel!
@IBOutlet weak var datePicker: UIDatePicker!

Add method that updates label text using date value from the date picker:

@IBAction
public func didChangeDate() {
    txtDate.text = NSDateFormatter.localizedStringFromDate(datePicker.date, dateStyle: .ShortStyle, timeStyle: .ShortStyle)
}

Select date picker and go to Connections Inspector. Drag from its Value Changed event to this method. Now add viewDidLoad method override:

public override func viewDidLoad() {
    didChangeDate()
}

This will update label’s text for the first time. Now build the project and run it. If you did everything correct, then label should change its text every time you change value of the date picker.

Toggle date picker on date row tap

We want to toggle date picker when user taps on the cell with Alarm date. Let’s override tableView(_:didSelectRowAtIndexPath:) method:

public override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
    switch (indexPath.section, indexPath.row) {
    case (1, 1):
        toggleDatePicker()
    default:
        ()
    }
}

This will invoke toggleDatePicker method if user tapped on the row with index 1 in the section with index 1. And this is the row we need.

How we should implement toggleDatePicker method? We can try to set row’s hidden property to true. This doesn’t work. We can try to set it’s height to zero. This also doesn’t work.

In order to achieve our goal we need to use tableView(_:heightForRowAtIndexPath:) method. This method provides heights for each table’s row. So we need a boolean property that holds information about visibility of the row and then use it inside the method to return zero height if date picker should not be visible:

private var datePickerHidden = false

public override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
    if datePickerHidden && indexPath.section == 1 && indexPath.row == 0 {
        return 0
    } else {
        return super.tableView(tableView, heightForRowAtIndexPath: indexPath)
    }
}

This method returns zero height for the date picker row if it should be hidden.

And now we can implement toggleDatePicker method:

private func toggleDatePicker() {
    datePickerHidden = !datePickerHidden

    // Force table to update its contents
    tableView.beginUpdates()
    tableView.endUpdates()
}

Date picker should be hidden when we load view for the first time:

public override func viewDidLoad() {
    didChangeDate()
    toggleDatePicker()
}

Compile and run…

To fix these display issues, you should go to storyboard, select row that contains date picker and set it’s Clip Subviews property to true.

Compile and run. Now it works as expected.

Refactoring

Let’s stop for a moment and look into the code we have:

public override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
    if datePickerHidden && indexPath.section == 1 && indexPath.row == 0 {
        return 0
    } else {
        return super.tableView(tableView, heightForRowAtIndexPath: indexPath)
    }
}

public override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
    switch (indexPath.section, indexPath.row) {
    case (1, 1):
        toggleDatePicker()
    default:
        ()
    }
}

I don’t like "magic" numbers here. Also, I don’t like duplication of row identification logic. Let’s fix this:

private enum Row: Int {
    case Reminder
    case RemindMeOnDay
    case Alarm
    case DatePicker
    case Repeat
    case RemindMeAtLocation
    case Location

    case Unknown


    init(indexPath: NSIndexPath) {
        var row = Row.Unknown

        switch (indexPath.section, indexPath.row) {
        case (0, 0):
            row = Row.Reminder
        case (1, 0):
            row = Row.RemindMeOnDay
        case (1, 1):
            row = Row.Alarm
        case (1, 2):
            row = Row.DatePicker
        case (1, 3):
            row = Row.Repeat
        case (2, 0):
            row = Row.RemindMeAtLocation
        case (2, 1):
            row = Row.Location
        default:
            ()
        }

        assert(row != Row.Unknown)

        self = row
    }
}

This enum replaces "magic" numbers with meaningful names, encapsulates NSIndex → RowName transformation logic, protects from mistakes.

Let’s rewrite our methods using this enum:

public override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
    let row = Row(indexPath: indexPath)

    if row == .Alarm {
        toggleDatePicker()
    }
}

public override func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
    let row = Row(indexPath: indexPath)

    return datePickerHidden && row == .DatePicker ? 0 : super.tableView(tableView, heightForRowAtIndexPath: indexPath)
}

This code is much better and less error prone.

Toggle other rows

Well, I will not show how to do this. It’s your exercise.

Thanks for reading this.

How to create an input form using UITableView

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

UITableView is a powerful UI element that is used in various scenarios of iOS application development.

In this article we will learn how to use it to build UI for input forms. When we finish implementation, we will have something similar to this:

Let’s get started

Create a Single View Application project, open Main.storyboard and delete view controller that is already there. Delete ViewController.swift file as well.

Drag and drop Table View Controller on the storyboard’s surface and make it initial view controller using Attribute Inspector:

UITableView can contain dynamic or static cells. We need the second one to build an input form:

Go to Document Outline and delete all table view cells except the first one.

Design Table Cell

Label, View and Text Field

Now we can design our cell. Later we will copy/paste it to create more table cells with the same visual appearance.

Drag and drop one Label, one View and one Text Field on the cell’s surface. Set background color of the View to #CCCCCC, and Alpha to 0.5. Reorder and change sizes of UI elements to correspond to the image below:

Select Table View Cell in the Document Outline and set its background to #FCFFE1, Then select the Label and set its font to Caption 1 and its color to #42AEDD. Set its alignment to Right. Now select the Text Field and set its border style to None. Finally, set its font to Body.

You should have something similar to this now:

Auto Layout

Let’s add Auto Layout constraints to the UI elements inside this cell.

Label

Select label and click on Pin button. Set constraints as shown in the screenshot below:

View

Select view and click on Pin button. Set constraints as shown in the screenshot:

Text Field

Now add constraints to the text field as shown in the screenshot:

Update Frames

Click on Resolve Auto Layout Issues button and select Update Frames menu item to make Interface Builder re-layout UI elements according to added Auto Layout constraints:

Now our table view cell should look like this:

Design Personal Info Section

Select Table View and set its style to Grouped:

This will make table view to show sections. Now select Table View Section in the Document Outline and set its Header property to Personal Info.

Select Table View Cell in the Document Outline and copy paste it four times. Now you should have five rows in the Personal Info section. Update text of labels inside these rows to values from the following list:

Nickname
First Name
Last Name
Password
Password (again)

Then select all table view cells and click on Update Frames. Now you should have something like this:

If labels' fonts are different after the Copy/Paste - just close and reopen Xcode. This should fix the issue.

Design Contact Info Section

Copy and paste previous section, change text, remove extra rows, update frames. This is how your table view should look like:

Make Labels to Have the Same Width

As you noticed, all labels have different widths and because of that vertical lines have different positions. There is a special Auto Layout constraint called Equal Widths:

This constraint makes all selected items to have the same width. Unfortunately, it’s not possible to apply it to the UI elements, that have different root views.

However it is possible to fix this in code:

Find label with the highest width value.
Add Auto Layout constraints to all labels to have exactly this width.

Create new Cocoa Touch Class, and inherit it from UITableViewController. Call it TableViewController. Then select Table View Controller in the storyboard and set its class to TableViewController in the Identity Controller.

Go back to the TableViewController class and remove all methods from it.

The following method calculates label’s width:

private func calculateLabelWidth(label: UILabel) -> CGFloat {
    let labelSize = label.sizeThatFits(CGSize(width: CGFloat.max, height: label.frame.height))

    return labelSize.width
}

I use sizeThatFits(_:) method of the UIView class to calculate size of the UILabel.

The next step is to find maximum width of labels:

private func calculateMaxLabelWidth(labels: [UILabel]) -> CGFloat {
    return reduce(map(labels, calculateLabelWidth), 0, max)
}

The next method adds Auto Layout constrains to constrain label widths:

private func updateWidthsForLabels(labels: [UILabel]) {
    let maxLabelWidth = calculateMaxLabelWidth(labels)
    for label in labels {
        let constraint = NSLayoutConstraint(item: label,
                                       attribute: .Width,
                                       relatedBy: .Equal,
                                          toItem: nil,
                                       attribute: .NotAnAttribute,
                                      multiplier: 1,
                                        constant: maxLabelWidth)
        label.addConstraint(constraint)
    }
}

Now we need list of labels to apply this method to. Add outlet collection property:

@IBOutlet var labels: [UILabel]!

And link it with all labels on the input form:

Update widths in viewDidLoad:

override func viewDidLoad() {
    updateWidthsForLabels(labels)
}

Compile and run:

The End

That’s it. I hope that was useful.

Oleksandr Manenko's Blog

The principle of type substitution

Subtype vs. Subclass

Supertype vs. Superclass

Type substitution

Java example

Python example

Variance

Covariance

Contravariance

Invariance

Conclusion

How to use Rust memory allocator from C

Нова країна

Sparse sets

Overview

An empty set

Adding a first item

Adding a second item

Adding a third item

Checking whether an item is in the set

Removing an item

Iterating over the set

Clearing the set

What’s next?

How to make Unreal Engine work correctly with CLion?

The problem

The solution

What about other IDEs and editors that support CMake?

Managing external dependencies with CMake

Typical project layout

Describing dependencies

Importing dependencies in subprojects

Hierarchical dependency management

Keep all dependencies in the same file

Each subproject describes its dependencies

Combination of the previous methods

The end

How to setup Emacs for Rust development

Initial setup

What to put into init.el file

Packages

Exec path [OS X only]

UI

Editing

Navigation

Miscellaneous

Text Completion

Rust Support

Install Racer

Install Rust sources

Configure Rust Support in Emacs

GDM doesn't load included files from .Xresources in Arch Linux

Put UIDatePicker inside static UITableView

Initial Setup

Rows' Setup

First row

Second row

Third row

Fourth row

Fifth row

Sixth row

Seventh row

Listen to DatePicker’s value changes

Toggle date picker on date row tap

Refactoring

Toggle other rows

How to create an input form using UITableView

Let’s get started

Design Table Cell

Label, View and Text Field

Auto Layout

Label

View

Text Field

Update Frames

Design Personal Info Section

Design Contact Info Section

Make Labels to Have the Same Width

The End