1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

// parser.h
#include "entity.h"

template <class T>
class ParserEventListener {
    public:
        virtual void update(T entity) = 0;
};

template <class T>
class Parser {
    public:
        virtual void add_listener(ParserEventListener<T*>* listener) = 0;
        virtual void remove_listener(ParserEventListener<T*>* listener) = 0;
        virtual void consume(char c, int pos) = 0;
        virtual Array<T*>* get_result() = 0;
        virtual void reset() = 0;
};

template <class T>
class AbstractParser: public Parser<T>, public ParserEventListener<T*> {
    public:
        static const int ZERO_STATE = 0;
        AbstractParser();
        virtual ~AbstractParser();
        void add_listener(ParserEventListener<T*>* listener);
        void remove_listener(ParserEventListener<T*>* listener);
        void update(T* entity);
        virtual void consume(char c, int pos) = 0;
        Array<T*>* get_result();
        virtual void reset() = 0;               
    protected:
        void add_context(T* value);
        bool has_state(int n, ...);
        int _state;
    private:
        Array<ParserEventListener<T*>*> _listeners;
        Array<T*> _context;
};

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

// scanner.h
#include "entity.h"
#include "parser.h"

#define CAPACITY 16
#define BUFFER_SIZE 1024

class Scanner: public ParserEventListener<Block*>, public ParserEventListener<Tag*>{
    public:
        Scanner();
        ~Scanner();
        void add_parser(Parser<Entity>* parser);
        void update(Block* block);
        void update(Tag* tag);
        Array<Entity*>* scan(char* source);
    private:
        Array<char>* read_source(char* source);
        Array<Entity*>* get_document();
        Block* _last_block;
        Array<Parser<Entity>*> _context;
};

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

// wsc.cpp
#include "parser.h"
#include "scanner.h"

using std::cout;
using std::cerr;
using std::endl;

void ws_export(Array<Entity*>*, std::string);
std::string ws_name(std::string);

int main(int argc, char** argv){
    Scanner scn;
    try {
        Parser<Entity>* parser = (Parser<Entity>*)new BlockParser;
        scn.add_parser(parser);
        
        parser = (Parser<Entity>*)new TagParser;
        scn.add_parser(parser);
        
        Array<Entity*>* doc = scn.scan(argv[1]);
        ws_export(doc, argv[1]);
        
        array_free(doc, true);
    } catch (const char* msg){
        cerr << msg << endl;
    }    
    return EXIT_SUCCESS;
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;

public class BankingAccount {

    public static void main(String[] args){
        List<Double> account = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);

        System.out.println("Bitte geben Sie Ihre Einzahlungen/Abbuchungen ein.");
        System.out.println("Sie beenden die Eingabe mit einer Leerzeile");
                
        String input;
        while ((input = scanner.nextLine()) != null){
            if (input.equals("")){
                break;
            }
            account.add(Double.valueOf(input));
        }
        double sum = account.stream().mapToDouble(Double::doubleValue).sum();

        double zins = 50;
        double result = sum * ((zins / 100) + 1);

        double diff = result - sum;

        if (zins > 0){
            System.out.println("Gewinn durch Zinsen: " + diff);
        } else {
            System.out.println("Verlust durch Zinsen: " + diff);
        }
        scanner.close();
    }
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

public interface Writer<T> {

    public static class Registry {

        private static final Map<Class, Writer> REGISTRY;

        static {
            REGISTRY = new HashMap<>();
            initDefaults();
        }

        private static void initDefaults(){
            register(Byte.class, new ByteWriter());
            register(Short.class, new ShortWriter());
            // [...]
            register(Object.class, new ObjectWriter());
        }

        public static <T> void register(Class<T> type, Writer<T> writer){
            REGISTRY.put(type, writer);
        }

        public static Writer<T> get(Class<T> type){
            return REGISTRY.get(type);
        }
    }

    public void write(/* whatsoever */);
}

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

public interface Writer<T> {

    public static class Registry {

        private static final Map<Class, Class> REGISTRY;

        static {
            REGISTRY = new HashMap<>();
            initDefaults();
        }

        private static void initDefaults(){
            register(Byte.class, ByteWriter.class);
            register(Short.class, ShortWriter.class);
            // [...]
            register(Object.class, ObjectWriter.class);
        }

        public static <T> void register(Class<T> type, Class<Writer<T>> writer){
            REGISTRY.put(type, writer);
        }

        public static Writer<T> get(Class<T> type) throws Exception{
            Class<Writer<T>> writerType = REGISTRY.get(type);

            if (writerType == null){
                throw new NullPointerException("No writer registered for class " + type.getName());
            }
            return writerType.newInstance();
        }
    }

    public void write(/* whatsoever */);
}