Download - Design Patterns in Modern C++
Design Patterns inModern C++, Part I
Dmitri Nesterukdmitrinеstеruk@gmаil.соm
@dnesteruk
What’s In This Talk?
• Examples of patterns and approaches in OOP design• Adapter• Composite• Specification pattern/OCP• Fluent and Groovy-style builders• Maybe monad
Adapter
STL String Complaints
• Making a string is easystring s{“hello world”};
• Getting its constituent parts is notvector<strings> words;boost::split(words, s, boost::is_any_of(“ “));
• Instead I would preferauto parts = s.split(“ “);
• It should work with “hello world”• Maybe some other goodies, e.g.
• Hide size()• Have length() as a property, not a function
Basic Adapter
class String {string s;
public:String(const string &s) : s{ s } { }
};
Implement Splitclass String {
string s;public:
String(const string &s) : s{ s } { }vector<string> split(string input){
vector<string> result;boost::split(result, s,
boost::is_any_of(input), boost::token_compress_on);return result;
}};
Length Proxying
class String {string s;
public:String(const string &s) : s{ s } { }vector<string> split(string input);size_t get_length() const { return s.length(); }
};
Length Proxying
class String {string s;
public:String(const string &s) : s{ s } { }vector<string> split(string input);size_t get_length() const { return s.length(); }
// non-standard!__declspec(property(get = get_length)) size_t length;
};
String Wrapper Usage
String s{ "hello world" };cout << "string has " << s.length << " characters" << endl;
auto words = s.split(" ");for (auto& word : words)cout << word << endl;
Adapter Summary
• Aggregate objects (or keep a reference)• Can aggregate more than one
• E.g., string and formatting
• Replicate the APIs you want (e.g., length)• Miss out on the APIs you don’t need• Add your own features :)
Composite
Scenario
• Neurons connect to other neurons
• Neuron layers are collections of neurons
• These two need to be connectable
Scenariostruct Neuron{
vector<Neuron*> in, out;unsigned int id;
Neuron(){
static int id = 1;this->id = id++;
}}
Scenario
struct NeuronLayer : vector<Neuron>{NeuronLayer(int count){while (count-- > 0)emplace_back(Neuron{});
}}
State Space Explosition
• void connect_to(Neuron& other){out.push_back(&other);other.in.push_back(this);
}• Unfortunately, we need 4 functions
• Neuron to Neuron• Neuron to NeuronLayer• NeuronLayer to Neuron• NeuronLayer to NeuronLayer
One Function Solution?
• Simple: treat Neuron as NeuronLayer of size 1• Not strictly correct• Does not take into account other concepts (e.g., NeuronRing)
• Better: expose a single Neuron in an iterable fashion• Other programming languages have interfaces for iteration
• E.g., C# IEnumerable<T>• yield keyword
• C++ does duck typing• Expects begin/end pair
• One function solution not possible, but…
Generic Connection Functionstruct Neuron{
...template <typename T> void connect_to(T& other){
for (Neuron& to : other)connect_to(to);
}template<> void connect_to<Neuron>(Neuron& other){
out.push_back(&other);other.in.push_back(this);
}};
Generic Connection Function
struct NeuronLayer : vector<Neuron>{…template <typename T> void connect_to(T& other){for (Neuron& from : *this)for (Neuron& to : other)from.connect_to(to);
}};
How to Iterate on a Single Value?
struct Neuron{…Neuron* begin() { return this; }Neuron* end() { return this + 1; }
};
API Usage
Neuron n, n2;NeuronLayer nl, nl2;
n.connect_to(n2);n.connect_to(nl);nl.connect_to(n);nl.connect_to(nl2);
Specification Pattern and the OCP
Open-Closed Principle
• Open for extension, closed for modification• Bad: jumping into old code to change a stable, functioning system• Good: making things generic enough to be externally extensible• Example: product filtering
Scenario
enum class Color { Red, Green, Blue };enum class Size { Small, Medium, Large };
struct Product{std::string name;Color color;Size size;
};
Filtering Productsstruct ProductFilter{
typedef std::vector<Product*> Items;static Items by_color(Items items, Color color){
Items result;for (auto& i : items)
if (i->color == color)result.push_back(i);
return result;}
}
Filtering Productsstruct ProductFilter{
typedef std::vector<Product*> Items;static Items by_color(Items items, Color color) { … }static Items by_size(Items items, Size size){
Items result;for (auto& i : items)
if (i->size == size)result.push_back(i);
return result;}
}
Filtering Productsstruct ProductFilter{
typedef std::vector<Product*> Items;static Items by_color(Items items, Color color) { … }static Items by_size(Items items, Size size) { … }static Items by_color_and_size(Items items, Size size, Color color){Items result;for (auto& i : items)
if (i->size == size && i->color == color)result.push_back(i);
return result;}
}
Violating OCP
• Keep having to rewrite existing code• Assumes it is even possible (i.e. you have access to source code)
• Not flexible enough (what about other criteria?)• Filtering by X or Y or X&Y requires 3 functions
• More complexity -> state space explosion
• Specification pattern to the rescue!
ISpecification and IFilter
template <typename T> struct ISpecification{virtual bool is_satisfied(T* item) = 0;
};template <typename T> struct IFilter{virtual std::vector<T*> filter(std::vector<T*> items, ISpecification<T>& spec) = 0;
};
A Better Filterstruct ProductFilter : IFilter<Product>{
typedef std::vector<Product*> Products;Products filter(
Products items, ISpecification<Product>& spec) override
{Products result;for (auto& p : items)
if (spec.is_satisfied(p))result.push_back(p);
return result;}
};
Making Specifications
struct ColorSpecification : ISpecification<Product>{Color color;explicit ColorSpecification(const Color color): color{color} { }
bool is_satisfied(Product* item) override {return item->color == color;
}}; // same for SizeSpecification
Improved Filter Usage
Product apple{ "Apple", Color::Green, Size::Small };Product tree { "Tree", Color::Green, Size::Large };Product house{ "House", Color::Blue, Size::Large };
std::vector<Product*> all{ &apple, &tree, &house };
ProductFilter pf;ColorSpecification green(Color::Green);
auto green_things = pf.filter(all, green);for (auto& x : green_things)std::cout << x->name << " is green" << std::endl;
Filtering on 2..N criteria
• How to filter by size and color?• We don’t want a SizeAndColorSpecification
• State space explosion
• Create combinators• A specification which combines two other specifications• E.g., AndSpecification
AndSpecification Combinatortemplate <typename T> struct AndSpecification : ISpecification<T>{
ISpecification<T>& first;ISpecification<T>& second;
AndSpecification(ISpecification<T>& first, ISpecification<T>& second)
: first{first}, second{second} { }
bool is_satisfied(T* item) override{
return first.is_satisfied(item) && second.is_satisfied(item);}
};
Filtering by Size AND Color
ProductFilter pf;ColorSpecification green(Color::Green);SizeSpecification big(Size::Large);AndSpecification<Product> green_and_big{ big, green };
auto big_green_things = pf.filter(all, green_and_big);for (auto& x : big_green_things)
std::cout << x->name << " is big and green" << std::endl;
Specification Summary
• Simple filtering solution is• Too difficult to maintain, violates OCP• Not flexible enough
• Abstract away the specification interface• bool is_satisfied_by(T something)
• Abstract away the idea of filtering• Input items + specification set of filtered items
• Create combinators (e.g., AndSpecification) for combining multiple specifications
Fluent and Groovy-Style Builders
Scenario
• Consider the construction of structured data• E.g., an HTML web page
• Stuctured and formalized• Rules (e.g., P cannot contain another P)• Can we provide an API for building these?
Building a Simple HTML List
// <ul><li>hello</li><li>world</li></ul>string words[] = { "hello", "world" };ostringstream oss;oss << "<ul>";for (auto w : words)
oss << " <li>" << w << "</li>";oss << "</ul>";printf(oss.str().c_str());
HtmlElement
struct HtmlElement{
string name;string text;vector<HtmlElement> elements;const size_t indent_size = 2;
string str(int indent = 0) const; // pretty-print}
Html Builder (non-fluent)
struct HtmlBuilder{
HtmlElement root;HtmlBuilder(string root_name) { root.name = root_name; }void add_child(string child_name, string child_text){
HtmlElement e{ child_name, child_text };root.elements.emplace_back(e);
}string str() { return root.str(); }
}
Html Builder (non-fluent)
HtmlBuilder builder{"ul"};builder.add_child("li", "hello")builder.add_child("li", "world");cout << builder.str() << endl;
Making It Fluent
struct HtmlBuilder{
HtmlElement root;HtmlBuilder(string root_name) { root.name = root_name; }HtmlBuilder& add_child(string child_name, string child_text){
HtmlElement e{ child_name, child_text };root.elements.emplace_back(e);return *this;
}string str() { return root.str(); }
}
Html Builder
HtmlBuilder builder{"ul"};builder.add_child("li", "hello").add_child("li", "world");cout << builder.str() << endl;
Associate Builder & Object Being Built
struct HtmlElement{
static HtmlBuilder build(string root_name){
return HtmlBuilder{root_name};}
};
// usage:HtmlElement::build("ul")
.add_child_2("li", "hello").add_child_2("li", "world");
Groovy-Style Builders
• Express the structure of the HTML in code• No visible function calls• UL {
LI {“hello”},LI {“world”}
}• Possible in C++ using uniform initialization
Tag (= HTML Element)
struct Tag{
string name;string text;vector<Tag> children;vector<pair<string, string>> attributes;
protected:Tag(const std::string& name, const std::string& text)
: name{name}, text{text} { }Tag(const std::string& name, const std::vector<Tag>& children)
: name{name}, children{children} { }}
Paragraph
struct P : Tag{
explicit P(const std::string& text): Tag{"p", text}
{}P(std::initializer_list<Tag> children): Tag("p", children)
{}
};
Image
struct IMG : Tag{
explicit IMG(const std::string& url): Tag{"img", ""}
{attributes.emplace_back(make_pair("src", url));
}};
Example Usage
std::cout <<
P {IMG {"http://pokemon.com/pikachu.png"}
}
<< std::endl;
Facet Builders
• An HTML element has different facets• Attributes, inner elements, CSS definitions, etc.
• A Person class might have different facets• Address• Employment information
• Thus, an object might necessitate several builders
Personal/Work Information
class Person{
// addressstd::string street_address, post_code, city;
// employmentstd::string company_name, position;int annual_income = 0;
Person() {} // private!}
Person Builder (Exposes Facet Builders)class PersonBuilder{
Person p;protected:
Person& person;explicit PersonBuilder(Person& person)
: person{ person } { }public:
PersonBuilder() : person{p} { }operator Person() { return std::move(person); }
// builder facetsPersonAddressBuilder lives();PersonJobBuilder works();
}
Person Builder (Exposes Facet Builders)class PersonBuilder{
Person p;protected:
Person& person;explicit PersonBuilder(Person& person)
: person{ person } { }public:
PersonBuilder() : person{p} { }operator Person() { return std::move(person); }
// builder facetsPersonAddressBuilder lives();PersonJobBuilder works();
}
Person Builder Facet Functions
PersonAddressBuilder PersonBuilder::lives(){
return PersonAddressBuilder{ person };}
PersonJobBuilder PersonBuilder::works(){
return PersonJobBuilder{ person };}
Person Address Builderclass PersonAddressBuilder : public PersonBuilder{
typedef PersonAddressBuilder Self;public:
explicit PersonAddressBuilder(Person& person) : PersonBuilder{ person } { }
Self& at(std::string street_address){
person.street_address = street_address;return *this;
}Self& with_postcode(std::string post_code);Self& in(std::string city);
};
Person Job Builder
class PersonJobBuilder : public PersonBuilder{
typedef PersonJobBuilder Self;public:
explicit PersonJobBuilder(Person& person) : PersonBuilder{ person } { }
Self& at(std::string company_name);Self& as_a(std::string position);Self& earning(int annual_income);
};
Back to Person
class Person{
// fieldspublic:
static PersonBuilder create();
friend class PersonBuilder;friend class PersonAddressBuilder;friend class PersonJobBuilder;
};
Final Person Builder Usage
Person p = Person::create().lives().at("123 London Road")
.with_postcode("SW1 1GB")
.in("London").works().at("PragmaSoft")
.as_a("Consultant")
.earning(10e6);
Maybe Monad
Presence or Absence
• Different ways of expressing absence of value• Default-initialized value
• string s; // there is no ‘null string’
• Null value• Address* address;
• Not-yet-initialized smart pointer• shared_ptr<Address> address
• Idiomatic• boost::optional
Monads
• Design patterns in functional programming• First-class function support• Related concepts
• Algebraic data types• Pattern matching
• Implementable to some degree in C++• Functional objects/lambdas
Scenario
struct Address{char* house_name; // why not string?
}
struct Person{Address* address;
}
Print House Name, If Any
void print_house_name(Person* p){if (p != nullptr &&
p->address != nullptr && p->address->house_name != nullptr)
{cout << p->address->house_name << endl;
}}
Maybe Monad
• Encapsulate the ‘drill down’ aspect of code• Construct a Maybe<T> which keeps context• Context: pointer to evaluated element
• person -> address -> name
• While context is non-null, we drill down• If context is nullptr, propagation does not happen• All instrumented using lambdas
Maybe<T>template <typename T>struct Maybe {
T* context;Maybe(T *context) : context(context) { }
};
// but, given Person* p, we cannot make a ‘new Maybe(p)’
template <typename T> Maybe<T> maybe(T* context){
return Maybe<T>(context);}
Usage So Far
void print_house_name(Person* p){maybe(p). // now drill down :)
}
Maybe::Withtemplate <typename T> struct Maybe{
...template <typename TFunc>auto With(TFunc evaluator){
if (context == nullptr)return ??? // cannot return maybe(nullptr) :(
return maybe(evaluator(context));};
}
What is ???
• In case of failure, we need to return Maybe<U>• But the type of U should be the return type of evaluator• But evaluator returns U* and we need U• Therefore…• return Maybe<
typename remove_pointer<decltype(evaluator(context))
>::type>(nullptr);
Maybe::With Finished
template <typename TFunc> auto With(TFunc evaluator){
if (context == nullptr)return Maybe<typename remove_pointer<
decltype(evaluator(context))>::type>(nullptr);return maybe(evaluator(context));
};
Usage So Far
void print_house_name(Person* p){maybe(p) // now drill down :).With([](auto x) { return x->address; }).With([](auto x) { return x->house_name; }). // print here (if context is not null)
}
Maybe::Do
template <typename TFunc>auto Do(TFunc action){// if context is OK, perform action on it if (context != nullptr) action(context);
// no context transition, so...return *this;
}
How It Works
• print_house_name(nullptr)• Context is null from the outset and continues to be null• Nothing happens in the entire evaluation chain
• Person p; print_house_name(&p);• Context is Person, but since Address is null, it becomes null henceforth
• Person p;p->Address = new Address;p->Address->HouseName = “My Castle”;print_house_name(&p);
• Everything works and we get our printout
Maybe Monad Summary
• Example is not specific to nullptr• E.g., replace pointers with boost::optional
• Default-initialized types are harder• If s.length() == 0, has it been initialized?
• Monads are difficult due to lack of functional support• [](auto x) { return f(x); } instead ofx => f(x) as in C#
• No implicits (e.g. Kotlin’s ‘it’)
That’s It!
• Questions?• Design Patterns in C++ courses on Pluralsight• dmitrinеsteruk /at/ gmail.com• @dnesteruk
Design Patterns in Modern C++, Part II
Dmitri Nesterukdmitrinеstеruk@gmаil.соm
@dnesteruk
What’s In This Talk?
• Part II of my Design Patterns talks• Part I of the talk available online in English and Russian
• Examples of design patterns implemented in C++• Disclaimer: C++ hasn’t internalized any patterns (yet)
• Patterns• Memento• Visitor• Observer• Interpreter
MementoHelping implement undo/redo
Bank Account
• Bank account has a balance• Balance changed via
• Withdrawals• Deposits
• Want to be able to undo an erroneous transaction
• Want to navigate to an arbitrary point in the account’s changeset
class BankAccount{
int balance{0};public:
void deposit(int x) {balance += x;
}void withdraw(int x) {
if (balance >= x)balance -= x;
}};
Memento (a.k.a. Token, Cookie)
class Memento{int balance;
public:Memento(int balance): balance(balance)
{}friend class BankAccount;
};
• Keeps the state of the balance at a particular point in time• State is typically private
• Can also keep reason for latest change, amount, etc.
• Returned during bank account changes
• Memento can be used to restore object to a particular state
Deposit and Restore
Memento deposit(int amount){balance += amount;return { balance };
}void restore(const Memento& m){balance = m.balance;
}
BankAccount ba{ 100 };auto m1 = ba.deposit(50); // 150auto m2 = ba.deposit(25); // 175// undo to m1ba.restore(m1); // 150// redoba.restore(m2); // 175
Storing Changes
class BankAccount {int balance{0}, current;vector<shared_ptr<Memento>> changes;
public:BankAccount(const int balance) : balance(balance){
changes.emplace_back(make_shared<Memento>(balance));current = 0;
}};
Undo and Redo
shared_ptr<Memento> deposit(intamount){balance += amount;auto m = make_shared<Memento>(balance);
changes.push_back(m);++current;return m;
}
shared_ptr<Memento> undo(){if (current > 0){--current;auto m = changes[current];balance = m->balance;return m;
}return{};
}
Undo/Redo Problems
• Storage excess• Need to store only changes, but still…
• Need to be able to overwrite the Redo step• Undo/redo is typically an aggregate operation
Cookie Monster!
• Why doesn’t push_back() return a reference?
• Well, it could, but…• As long as you’re not resizing due
to addition• How to refer to an element of
vector<int>?• Dangerous unless append-only• Change to vector< shared_ptr<int>>• Change to list<int>• Some range-tracking magic token
solution
• Return a magic_cookie that• Lets you access an element provided
it exists• Is safe to use if element has been
deleted• Keeps pointing to the correct element
even when container is reordered• Requires tracking all mutating
operations• Is it worth it?
ObserverThis has been done to death, but…
Simple Model
class Person{int age;
public:void set_age(int age){this->age = age;
}int get_age() const{return age;
}};
• Person has an age: private field with accessor/mutator
• We want to be informedwhenever age changes
• Need to modify the setter!
Person Listener
struct PersonListener{virtual ~PersonListener() = default;virtual void person_changed(Person& p,
const string& property_name, const any new_value) = 0;};
Person Implementation
class Person{vector<PersonListener*> listeners;
public:void subscribe(PersonListener* pl) {listeners.push_back(pl);
}void notify(const string& property_name, const any new_value){for (const auto listener : listeners)listener->person_changed(*this, property_name, new_value);
}};
Setter Change
void set_age(const int age){if (this->age == age) return;this->age = age;notify("age", this->age);
}
Consumption
struct ConsoleListener : PersonListener{void person_changed(Person& p,
const string& property_name, const any new_value) override
{cout << "person's " << property_name
<< " has been changed to ";if (property_name == "age"){
cout << any_cast<int>(new_value);}cout << "\n";
}};
Person p{14};ConsoleListener cl;p.subscribe(&cl);p.set_age(15);p.set_age(16);
Dependent Property
bool get_can_vote() const{return age >= 16;
}
• Where to notify?• How to detect that any
affecting property has changed?
• Can we generalize?
Notifying on Dependent Property
void set_age(const int age){if (this->age == age) return;
auto old_c_v = get_can_vote();
this->age = age;notify("age", this->age);
auto new_c_v = get_can_vote();if (old_c_v != new_c_v){
notify("can_vote", new_c_v);}
}
save old value
get new value compare and notify only if
changed
Observer Problems
• Multiple subscriptions by a single listener• Are they allowed? If not, use std::set
• Un-subscription• Is it supported?• Behavior if many subscriptions/one listener?
• Thread safety• Reentrancy
Thread Safetystatic mutex mtx;class Person {⋮void subscribe(PersonListener* pl){lock_guard<mutex> guard{mtx};⋮
}void unsubscribe(PersonListener* pl){lock_guard<mutex> guard{mtx};for (auto it : listeners){if (*it == pl) *it = nullptr;// erase-remove in notify()
}}
};
• Anything that touches the list of subscribers is locked• Reader-writer locks better (shared_lock for
reading, unique_lock for writing)
• Unsubscription simply nulls the listener• Must check for nullptr• Remove at the end of notify()
• Alternative: use concurrent_vector• Guaranteed thread-safe addition• No easy removal
Reentrancy
struct TrafficAdministration : Observer<Person>{void field_changed(Person& source,
const string& field_name){
if (field_name == "age"){if (source.get_age() < 17)
cout << "Not old enough to drive!\n";else{
// let's not monitor them anymorecout << "We no longer care!\n";source.unsubscribe(this);
}}}};
Age changes (1617):• notify() called• Lock taken
field_changed• unsubscribe()
unsubscribe()• Tries to take a lock• But it’s already taken
Observer Problems
• Move from mutex to recursive_mutex• Doesn’t solve all problems• See Thread-safe Observer Pattern – You’re doing it Wrong (Tony Van
Eerd)
Boost.Signals2• signal<T>
• A signal that can be sent to anyone willing to listen
• T is the type of the slot function• A slot is the function that receives the
signal• Ordinary function• Functor, std::function• Lambda
• Connection• signal<void()> s;
creates a signal• auto c = s.connect([](){
cout << “test” << endl;});connects the signal to the slot
• More than one slot can be connected to a signal
• Disconnection• c.disconnect();• Disconnects all slots
• Slots can be blocked• Temporarily disabled• Used to prevent infinite recursion• shared_connection_block(c)• Unblocked when block is destroyed, or
explicitly viablock.unblock();
INotifyPropertyChanged<T>
template <typename T>struct INotifyPropertyChanged{virtual ~INotifyPropertyChanged() = default;signal<void(T&, const string&)> property_changed;
};struct Person : INotifyPropertyChanged<Person>{void set_age(const int age){if (this->age == age) return;
this->age = age;property_changed(*this, "age");}
};
Consuming INPC Model
Person p{19};p.property_changed.connect(
[](Person&, const string& prop_name){
cout << prop_name << " has been changed" << endl;});
p.set_age(20);
InterpreterMake your own programming language!
Interpreter
• Interpret textual input• A branch of computer science
• Single item: atoi, lexical_cast, etc.• Custom file format: XML, CSV• Embedded DSL: regex• Own programming language
Interpreting Numeric Expressions
(13-4)-(12+1)
Lex: [(] [13] [-] [4] [)] [-] …
Parse: Op(-, Op(-, 13, 4), Op(+,12,1))
Token
struct Token{enum Type { integer, plus, minus, lparen, rparen
} type;
string text;
explicit Token(Type type, const string& text) :type{type}, text{text} {}
};
Lexingvector<Token> lex(const string& input){
vector<Token> result;for (int i = 0; i < input.size(); ++i){
switch (input[i]){case '+':
result.push_back(Token{ Token::plus, "+" });break;
case '-':result.push_back(Token{ Token::minus, "-" });break;
case '(':result.push_back(Token{ Token::lparen, "(" });break;
case ')':result.push_back(Token{ Token::rparen, ")" });break;
default:ostringstream buffer;buffer << input[i];for (int j = i + 1; j < input.size(); ++j){
if (isdigit(input[j])){buffer << input[j];++i;
}else{result.push_back(Token{ Token::integer, buffer.str() });
break;}
}…
Parsing Structuresstruct Element{virtual ~Element() = default;virtual int eval() const = 0;
};
struct Integer : Element{int value;explicit Integer(const int value): value(value)
{}int eval() const override { return value;
}};
struct BinaryOperation : Element{enum Type { addition, subtraction } type;shared_ptr<Element> lhs, rhs;
int eval() const override{if (type == addition) return lhs->eval() + rhs->eval();
return lhs->eval() - rhs->eval();}
};shared_ptr<Element> parse(const vector<Token>& tokens){⋮
}
Parsing Numeric Expressions
string input{ "(13-4)-(12+1)" };auto tokens = lex(input);try {auto parsed = parse(tokens);cout << input << " = " << parsed->eval() << endl;
} catch (const exception& e){cout << e.what() << endl;
}
Boost.Sprit
• A Boost library for interpreting text• Uses a de facto DSL for defining the parser• Defining a separate lexer not mandatory• Favors Boost.Variant for polymorphic types• Structurally matches definitions to OOP structures
Tlön Programming Language
• Proof-of-concept language transpiled into C++• Parser + pretty printer + notepadlike app• Some language features
• Shorter principal integral types• Primary constructors• Tuples• Non-keyboard characters (keyboard-unfriendly)
Visitor
Adding Side Functionality to Classes
• C++ Committee not liking UCS• Or any other “extension function” kind of deal• Possible extensions on hierarchies end up being intrusive
• Need to modify the entire hierarchy
That’s It!
• Design Patterns in C++ courses on Pluralsight• Leanpub book (work in progress!)• Tlön Programming Language• dmitrinеsteruk /at/ gmail.com• @dnesteruk
