├── SimpleMailForwarderDkim
    ├── Dockerfile
    │   ├── TrustedHosts
    │   ├── supervisord.conf
    │   ├── opendkim.conf
    │   └── Dockerfile
    └── docker-compose.yml
├── WordPressDocker
    ├── php-uploads.ini
    ├── nginx.conf
    └── docker-compose.yml
├── Common.Wpf
    ├── Common.Wpf.csproj
    ├── ViewModel
    │   └── ViewModelBase.cs
    └── Command
    │   ├── CommandBase.cs
    │   └── GenericCommand.cs
├── InterviewPrep
    ├── Codility
    │   └── Palladium2020
    │   │   ├── Palladium2020.csproj
    │   │   ├── Palladium2020.sln
    │   │   └── Program.cs
    └── LeetCode
    │   ├── find-the-town-judge.py
    │   ├── reorganize-string.py
    │   ├── remove-linked-list-elements.py
    │   └── find-and-replace-in-string.py
├── ReflectionEmitClassGeneration
    ├── ViewModel
    │   ├── ItemViewModelBase.cs
    │   └── MainWindowViewModel.cs
    ├── App.xaml
    ├── ReflectionEmitClassGeneration.csproj
    ├── App.xaml.cs
    ├── View
    │   ├── MainWindow.xaml.cs
    │   └── MainWindow.xaml
    ├── ReflectionEmitClassGeneration.sln
    └── Types
    │   └── TypeGenerator.cs
├── TPLDataflowProcessing
    ├── App.xaml.cs
    ├── App.xaml
    ├── TPLDataflowProcessing.csproj
    ├── View
    │   ├── MainWindow.xaml.cs
    │   └── MainWindow.xaml
    ├── TPLDataflowProcessing.sln
    ├── Model
    │   └── MockPriceFeed.cs
    └── ViewModel
    │   ├── PriceEventViewModel.cs
    │   └── MainWindowViewModel.cs
├── README.md
├── react-native-firebase-socialauth
    ├── GoogleProvider.js
    ├── TwitterProvider.js
    ├── FacebookProvider.js
    ├── LoginFunctions.js
    └── EmailProvider.js
├── .gitignore
└── LICENSE


/SimpleMailForwarderDkim/Dockerfile/TrustedHosts:
--------------------------------------------------------------------------------
1 | 127.0.0.1
2 | localhost
3 | 192.168.0.1/24
4 | 


--------------------------------------------------------------------------------
/WordPressDocker/php-uploads.ini:
--------------------------------------------------------------------------------
 1 | 
 2 | #
 3 | # Allow larger file uploads
 4 | #
 5 | file_uploads = On
 6 | memory_limit = 64M
 7 | upload_max_filesize = 64M
 8 | post_max_size = 64M
 9 | max_execution_time = 600
10 | 
11 | 


--------------------------------------------------------------------------------
/Common.Wpf/Common.Wpf.csproj:
--------------------------------------------------------------------------------
1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
2 | 
3 |   <PropertyGroup>
4 |     <TargetFramework>netcoreapp3.0</TargetFramework>
5 |     <UseWPF>true</UseWPF>
6 |   </PropertyGroup>
7 | 
8 | </Project>
9 | 


--------------------------------------------------------------------------------
/InterviewPrep/Codility/Palladium2020/Palladium2020.csproj:
--------------------------------------------------------------------------------
1 | <Project Sdk="Microsoft.NET.Sdk">
2 | 
3 |   <PropertyGroup>
4 |     <OutputType>Exe</OutputType>
5 |     <TargetFramework>netcoreapp3.1</TargetFramework>
6 |   </PropertyGroup>
7 | 
8 | </Project>
9 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/ViewModel/ItemViewModelBase.cs:
--------------------------------------------------------------------------------
 1 | using Common.Wpf.ViewModel;
 2 | 
 3 | namespace ReflectionEmitClassGeneration.ViewModel
 4 | {
 5 |     public class ItemViewModelBase: ViewModelBase
 6 |     {
 7 |         public ItemViewModelBase()
 8 |         {
 9 | 
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="ReflectionEmitClassGeneration.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              StartupUri="View/MainWindow.xaml">
 5 |     <Application.Resources>
 6 |          
 7 |          
 8 |     </Application.Resources>
 9 | </Application>
10 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/ReflectionEmitClassGeneration.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>WinExe</OutputType>
 5 |     <TargetFramework>netcoreapp3.0</TargetFramework>
 6 |     <UseWPF>true</UseWPF>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <ProjectReference Include="..\Common.Wpf\Common.Wpf.csproj" />
11 |   </ItemGroup>
12 | </Project>


--------------------------------------------------------------------------------
/SimpleMailForwarderDkim/Dockerfile/supervisord.conf:
--------------------------------------------------------------------------------
 1 | [supervisord]
 2 | nodaemon=true
 3 | 
 4 | [program:smf]
 5 | command=/entrypoint.sh
 6 | autostart = true
 7 | autorestart = true
 8 | stdout_logfile=/dev/stdout
 9 | stdout_logfile_maxbytes=0
10 | [program:smfopendkim]
11 | command=/usr/sbin/opendkim -f -x /etc/opendkim/opendkim.conf
12 | 
13 | autostart = true
14 | stdout_logfile=/dev/stdout
15 | stdout_logfile_maxbytes=0


--------------------------------------------------------------------------------
/TPLDataflowProcessing/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace TPLDataflowProcessing
10 | {
11 |     /// <summary>
12 |     /// Interaction logic for App.xaml
13 |     /// </summary>
14 |     public partial class App : Application
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="TPLDataflowProcessing.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |              xmlns:local="clr-namespace:TPLDataflowProcessing"
 5 |              StartupUri="View/MainWindow.xaml">
 6 |     <Application.Resources>
 7 |          
 8 |     </Application.Resources>
 9 | </Application>
10 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/App.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Configuration;
 4 | using System.Data;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using System.Windows;
 8 | 
 9 | namespace ReflectionEmitClassGeneration
10 | {
11 |     /// <summary>
12 |     /// Interaction logic for App.xaml
13 |     /// </summary>
14 |     public partial class App : Application
15 |     {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/View/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | using ReflectionEmitClassGeneration.ViewModel;
 2 | using System.Collections.ObjectModel;
 3 | using System.ComponentModel;
 4 | using System.Windows;
 5 | 
 6 | namespace ReflectionEmitClassGeneration.View
 7 | {
 8 |     /// <summary>
 9 |     /// Interaction logic for MainWindow.xaml
10 |     /// </summary>
11 |     public partial class MainWindow : Window
12 |     {
13 |         public MainWindow()
14 |         {
15 |             InitializeComponent();
16 | 
17 |         }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Common.Wpf/ViewModel/ViewModelBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.ComponentModel;
 3 | using System.Runtime.CompilerServices;
 4 | 
 5 | namespace Common.Wpf.ViewModel
 6 | {
 7 |     public abstract class ViewModelBase : INotifyPropertyChanged
 8 |     {
 9 |         public event PropertyChangedEventHandler PropertyChanged;
10 | 
11 |         public void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
12 |         {
13 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
14 |         }
15 | 
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Common.Wpf/Command/CommandBase.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Windows.Input;
 3 | 
 4 | namespace Common.Wpf.Command
 5 | {
 6 |     public abstract class CommandBase : ICommand
 7 |     {
 8 |         public virtual bool CanExecute(object parameter)
 9 |         {
10 |             return true;
11 |         }
12 | 
13 |         public abstract void Execute(object parameter);
14 | 
15 |         public event EventHandler CanExecuteChanged
16 |         {
17 |             add { CommandManager.RequerySuggested += value; }
18 |             remove { CommandManager.RequerySuggested -= value; }
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/TPLDataflowProcessing.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>WinExe</OutputType>
 5 |     <TargetFramework>netcoreapp3.0</TargetFramework>
 6 |     <UseWPF>true</UseWPF>
 7 |   </PropertyGroup>
 8 | 
 9 |   <ItemGroup>
10 |     <PackageReference Include="System.Threading.Tasks.Dataflow" Version="4.11.1" />
11 |   </ItemGroup>
12 | 
13 |   <ItemGroup>
14 |     <Folder Include="Processors\" />
15 |   </ItemGroup>
16 | 
17 |   <ItemGroup>
18 |     <ProjectReference Include="..\Common.Wpf\Common.Wpf.csproj" />
19 |   </ItemGroup>
20 | 
21 | </Project>


--------------------------------------------------------------------------------
/SimpleMailForwarderDkim/Dockerfile/opendkim.conf:
--------------------------------------------------------------------------------
 1 | AutoRestart             Yes
 2 | AutoRestartRate         10/1h
 3 | UMask                   002
 4 | Syslog                  yes
 5 | SyslogSuccess           Yes
 6 | LogWhy                  Yes
 7 | Canonicalization        relaxed/simple
 8 | ExternalIgnoreList      refile:/etc/opendkim/TrustedHosts
 9 | InternalHosts           refile:/etc/opendkim/TrustedHosts
10 | KeyTable                refile:/etc/opendkim/KeyTable
11 | SigningTable            refile:/etc/opendkim/SigningTable
12 | Mode                    sv
13 | PidFile                 /var/run/opendkim/opendkim.pid
14 | SignatureAlgorithm      rsa-sha256
15 | UserID                  opendkim:opendkim
16 | Socket                  inet:8891@localhost
17 | 


--------------------------------------------------------------------------------
/SimpleMailForwarderDkim/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3.7'
 2 | 
 3 | services:
 4 |    mail:
 5 |      build:
 6 |        context: Dockerfile
 7 |        dockerfile: Dockerfile
 8 |        args:
 9 |         SMF_EMAILDOMAIN: 'yourdomain.com'
10 |      container_name: mail
11 |      ports:
12 |        - 25:25
13 |        - 110:110
14 |        - 995:995
15 |        - 993:993
16 |        - 143:143
17 |        - 465:465
18 |        - 587:587
19 |        - 4190:4190
20 |      restart: always
21 |      volumes:
22 |        - ./ssl_certs/smtp.key:/etc/postfix/cert/smtp.key
23 |        - ./ssl_certs/smtp.cert:/etc/postfix/cert/smtp.cert
24 |        - ./dkim/:/etc/opendkim/keys/
25 |      environment:
26 |         SMF_CONFIG: 'yourdomain.com:your@email.com'
27 |         SMF_DOMAIN: 'yourdomain.com'
28 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/View/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Threading.Tasks;
 6 | using System.Windows;
 7 | using System.Windows.Controls;
 8 | using System.Windows.Data;
 9 | using System.Windows.Documents;
10 | using System.Windows.Input;
11 | using System.Windows.Media;
12 | using System.Windows.Media.Imaging;
13 | using System.Windows.Navigation;
14 | using System.Windows.Shapes;
15 | 
16 | namespace TPLDataflowProcessing
17 | {
18 |     /// <summary>
19 |     /// Interaction logic for MainWindow.xaml
20 |     /// </summary>
21 |     public partial class MainWindow : Window
22 |     {
23 |         public MainWindow()
24 |         {
25 |             InitializeComponent();
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/InterviewPrep/LeetCode/find-the-town-judge.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | class Solution:
 3 |     def findJudge(self, N: int, trust: List[List[int]]) -> int:
 4 |         trustCount = {}
 5 |         for i in range(N):
 6 |             trustCount[i+1] = {"trusts": 0, "trusted": 0}
 7 |         for entry in trust:
 8 |             trustCount[entry[0]]["trusts"] += 1
 9 |             trustCount[entry[1]]["trusted"] += 1
10 |         couldBeJudge = None
11 |         for i in range(N):
12 |             entry = trustCount[i + 1]
13 |             if entry["trusts"] == 0 and entry["trusted"] == N -1:
14 |                 if couldBeJudge is not None:
15 |                     return -1
16 |                 couldBeJudge = i + 1
17 |         if couldBeJudge is None:
18 |             return -1
19 |         return couldBeJudge
20 | 
21 | sol = Solution()
22 | result = sol.findJudge(2, [[1,2]])
23 | print(result)


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Public Samples
 2 | You can find various snippets available for educational purposes in this repo:
 3 | ### WordPress Docker
 4 | Docker-compose files to allow you to spin up a wordpress site with https
 5 | ### Simple Mail Forwarder DKIM
 6 | Attempt at using docker-compose to spin up Zixia's Simple Mail Forwarder with added DKIM signing on top
 7 | ### React Native Firebase Social Auth
 8 | React Native samples on how to sign up users using Firebase's social auth and email/password signup
 9 | ### Reflection.Emit Class Generation
10 | C# .NET Core code and sample WPF app showing how to generate a new type at runtime using Reflection.Emit
11 | ### TPL Dataflow Processing Pipeline
12 | C# .NET Core app to demo functionality of the TPL Dataflow library for parallel data processing
13 | ### Interview Prep
14 | Code snippets for various Codility and LeetCode questions in Python and C#
15 | 
16 | 


--------------------------------------------------------------------------------
/Common.Wpf/Command/GenericCommand.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Common.Wpf.Command
 4 | {
 5 |     public class GenericCommand : CommandBase
 6 |     {
 7 |         private readonly Action _commandAction;
 8 |         private readonly Func<object, bool> _canExecute;
 9 | 
10 |         public GenericCommand(Action commandAction)
11 |         {
12 |             _commandAction = commandAction;
13 |         }
14 | 
15 |         public GenericCommand(Action commandAction, Func<object, bool> canExecute) : this(commandAction)
16 |         {
17 |             _canExecute = canExecute;
18 |         }
19 | 
20 |         public override void Execute(object parameter)
21 |         {
22 |             _commandAction.Invoke();
23 |         }
24 | 
25 |         public override bool CanExecute(object obj)
26 |         {
27 |             var result = ((_canExecute == null) ||
28 |                 (_canExecute != null && _canExecute(obj))) &&
29 | 
30 |                 base.CanExecute(obj);
31 | 
32 |             return result;
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/InterviewPrep/LeetCode/reorganize-string.py:
--------------------------------------------------------------------------------
 1 | class Solution:
 2 |     def reorganizeString(self, S: str) -> str:
 3 |         charDict = {}
 4 |         for c in S:
 5 |             if c in charDict:
 6 |                 charDict[c] = charDict[c] + 1
 7 |             else:
 8 |                 charDict[c] = 1
 9 |         maxVal = max(charDict.values())
10 |         
11 |         result = ''
12 |         if maxVal > ((len(S) / 2) + 0.5):
13 |             return result
14 |         
15 |         while len(result) != len(S):
16 |             sortedKeys = sorted(charDict, key=charDict.get, reverse=True)
17 |             result = result + sortedKeys[0]
18 |             charDict[sortedKeys[0]] = charDict[sortedKeys[0]] - 1
19 |             if charDict[sortedKeys[1]] > 0:
20 |                 result = result + sortedKeys[1]
21 |                 charDict[sortedKeys[1]] = charDict[sortedKeys[1]] - 1
22 | 
23 |         return result
24 | 
25 | sol = Solution()
26 | result = sol.reorganizeString("aaab")
27 | print(result)
28 | result = sol.reorganizeString("aab")
29 | print(result)
30 | result = sol.reorganizeString("aaacb")
31 | print(result)


--------------------------------------------------------------------------------
/react-native-firebase-socialauth/GoogleProvider.js:
--------------------------------------------------------------------------------
 1 | import React, { Component } from 'react';
 2 | import { Button } from 'react-native'
 3 | import auth from '@react-native-firebase/auth';
 4 | import { GoogleSignin } from '@react-native-community/google-signin';
 5 | import LoginFunctions from './LoginFunctions';
 6 | 
 7 | const webClientId =  "YOUR_KEY_HERE";
 8 | 
 9 | export default class GoogleProvider extends Component {
10 |   constructor(props) {
11 |     super(props)
12 |   }
13 | 
14 |   render() {
15 |     return (
16 |       <Button
17 |         title="Google Sign-In"
18 |         onPress={() => {
19 |           onGoogleButtonPress();
20 |         }}
21 |       />
22 |     );
23 |   }
24 | };
25 | 
26 | async function onGoogleButtonPress() {
27 |   try {
28 |     GoogleSignin.configure({
29 |       webClientId: this.webClientId,
30 |       scopes: ['email', 'profile']
31 |     })
32 | 
33 |     const data = await GoogleSignin.signIn();
34 |     let credential = auth.GoogleAuthProvider.credential(data.idToken);
35 | 
36 |     return LoginFunctions.signInOrLink(auth.GoogleAuthProvider.PROVIDER_ID, credential, data.user.email);
37 |   }
38 |   catch (error) {
39 |     console.log(error.message);
40 |   }
41 | }


--------------------------------------------------------------------------------
/InterviewPrep/Codility/Palladium2020/Palladium2020.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.30406.217
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Palladium2020", "Palladium2020.csproj", "{79DEFBA6-736F-4342-B382-90ED6B12E4DA}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{79DEFBA6-736F-4342-B382-90ED6B12E4DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{79DEFBA6-736F-4342-B382-90ED6B12E4DA}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{79DEFBA6-736F-4342-B382-90ED6B12E4DA}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{79DEFBA6-736F-4342-B382-90ED6B12E4DA}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {31084391-22A8-43D2-97C3-F538492AC341}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/InterviewPrep/LeetCode/remove-linked-list-elements.py:
--------------------------------------------------------------------------------
 1 | # Definition for singly-linked list.
 2 | class ListNode:
 3 |     def __init__(self, val=0, next=None):
 4 |         self.val = val
 5 |         self.next = next
 6 | class Solution:
 7 |     def removeElements(self, head: ListNode, val: int) -> ListNode:
 8 |         if head == None:
 9 |             return None
10 | 
11 |         while head.val == val:
12 |             if head.next is None:
13 |                 return None
14 |             head = head.next
15 |             
16 |         ptr = head
17 |         while ptr.next is not None:
18 |             if ptr.next.val == val:
19 |                 ptr.next = ptr.next.next
20 |             else:
21 |                 ptr = ptr.next
22 | 
23 |         return head
24 |             
25 | sol = Solution()
26 | # [1,2,6,3,4,5,6]
27 | # 6
28 | # [6,6,6]
29 | # 6
30 | # [6,5,6]
31 | # 6
32 | # [1]
33 | # 2
34 | input = ListNode(1,ListNode(2,ListNode(6,ListNode(3,ListNode(4,ListNode(5,ListNode(6)))))))
35 | result = sol.removeElements(input, 6)
36 | input = ListNode(6,ListNode(6,ListNode(6)))
37 | result = sol.removeElements(input, 6)
38 | input = ListNode(6,ListNode(5,ListNode(6)))
39 | result = sol.removeElements(input, 6)
40 | input = ListNode(1)
41 | 
42 | result = sol.removeElements(input, 2)
43 | 


--------------------------------------------------------------------------------
/react-native-firebase-socialauth/TwitterProvider.js:
--------------------------------------------------------------------------------
 1 | import React, { Component } from 'react';
 2 | import { Button } from 'react-native';
 3 | import auth from '@react-native-firebase/auth';
 4 | import { NativeModules } from 'react-native';
 5 | import LoginFunctions from './LoginFunctions';
 6 | 
 7 | const { RNTwitterSignIn } = NativeModules;
 8 | const config = {
 9 |   consumer_key: "YOUR_KEY_HERE",
10 |   consumer_secret: "YOUR_SECRET_HERE"
11 | };
12 | export default class TwitterProvider extends Component {
13 |   constructor(props) {
14 |     super(props);
15 |   }
16 | 
17 |   render() {
18 |     return (
19 |       <Button
20 |         title="Twitter Sign-In"
21 |         onPress={() => { onTwitterButtonPress(); }}
22 |       />
23 |     );
24 |   }
25 | }
26 | 
27 | async function onTwitterButtonPress() {
28 |   try {
29 |     RNTwitterSignIn.init(config.consumer_key, config.consumer_secret)
30 |     var loginData = await RNTwitterSignIn.logIn();
31 | 
32 |     const { authToken, authTokenSecret, email } = loginData;
33 |     const credential = auth.TwitterAuthProvider.credential(authToken, authTokenSecret)
34 |     await LoginFunctions.signInOrLink(auth.TwitterAuthProvider.PROVIDER_ID, credential, email)
35 |   }
36 |   catch (err) {
37 |     console.log(error.message);
38 |   }
39 | }


--------------------------------------------------------------------------------
/WordPressDocker/nginx.conf:
--------------------------------------------------------------------------------
 1 | server {
 2 |     listen 80;
 3 |     server_name www.yourdomain.com;
 4 |  
 5 |     root /var/www/html/site;
 6 |     index index.php;
 7 |  
 8 |     access_log /var/log/nginx/site_access.log;
 9 |     error_log /var/log/nginx/site_error.log;
10 | 
11 |     client_max_body_size 64M;
12 | 
13 |     pagespeed on;
14 |     pagespeed ModifyCachingHeaders on;
15 |     pagespeed FileCachePath /var/ngx_pagespeed_cache_blog;
16 |     pagespeed MapOriginDomain "http://localhost" "https://www.yourdomain.com";
17 |     pagespeed LoadFromFile "https://www.yourdomain.com" "/var/www/html/site";
18 |     pagespeed EnableFilters rewrite_css,combine_css,trim_urls,combine_javascript,insert_ga,resize_images;
19 | 	pagespeed AnalyticsID "";
20 |     pagespeed DisableFilters sprite_images,convert_jpg_to_webp,convert_to_webp_lossless;
21 | 	
22 |     location ~ "\.pagespeed\.([a-z]\.)?[a-z]{2}\.[^.]{10}\.[^.]+" {
23 |         add_header "" "";
24 |     }
25 |     location ~ "^/pagespeed_static/" { }
26 |     location ~ "^/ngx_pagespeed_beacon$" { }
27 |   
28 |     location / {
29 |         try_files $uri $uri/ /index.php?$args;
30 |     }
31 |  
32 |     location ~ \.php$ {
33 |         try_files $uri =404;
34 |         fastcgi_split_path_info ^(.+\.php)(/.+)$;
35 |         fastcgi_pass site:9000;
36 |         fastcgi_index index.php;
37 |         include fastcgi_params;
38 |         fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
39 |         fastcgi_param PATH_INFO $fastcgi_path_info;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/WordPressDocker/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3.7'
 2 | 
 3 | services:
 4 |    db:
 5 |      image: mysql:5.7
 6 |      container_name: db
 7 |      restart: always
 8 |      volumes:
 9 |        - ./blogsite_db:/var/lib/mysql
10 |      environment:
11 |        MYSQL_ROOT_PASSWORD: rootpassword
12 |        MYSQL_DATABASE: wordpress
13 |        MYSQL_USER: admin
14 |        MYSQL_PASSWORD: password
15 | 
16 |    site:
17 |      image: wordpress:5.2.3-php7.3-fpm-alpine
18 |      container_name: site
19 |      depends_on:
20 |        - db
21 |      restart: always
22 |      working_dir: /var/www/html/site
23 |      volumes:
24 |        - ./php-uploads.ini:/usr/local/etc/php/conf.d/uploads.ini
25 |        - ./site_wp:/var/www/html/site
26 |      environment:
27 |        WORDPRESS_DB_HOST: db:3306
28 |        WORDPRESS_DB_USER: admin
29 |        WORDPRESS_DB_PASSWORD: password
30 | 
31 |    web:
32 |      image: pagespeed/nginx-pagespeed
33 |      container_name: web
34 |      depends_on:
35 |        - site
36 |      restart: always
37 |      volumes:
38 |        - ./nginx.conf:/etc/nginx/conf.d/default.conf
39 |        - ./sites-available:/etc/nginx/sites-available
40 |        - ./blogsite_wp:/var/www/html/site
41 |        - ./logs:/var/log/nginx
42 | 
43 |    https:
44 |      image: steveltn/https-portal:1
45 |      container_name: https
46 |      depends_on:
47 |        - web
48 |      ports:
49 |        - 80:80
50 |        - 443:443
51 |      restart: always
52 |      volumes:
53 |        - ./ssl_certs:/var/lib/https-portal
54 |      environment:
55 |        DOMAINS: 'www.yourdomain.com -> http://web:80 #production'
56 |        CLIENT_MAX_BODY_SIZE: 64M
57 | 
58 | 


--------------------------------------------------------------------------------
/SimpleMailForwarderDkim/Dockerfile/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM zixia/simple-mail-forwarder:1.1
 2 | LABEL maintainer="cheungt6"
 3 | ARG SMF_EMAILDOMAIN
 4 | 
 5 | # https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy
 6 | 
 7 | RUN apk --no-cache add opendkim supervisor
 8 | 
 9 | WORKDIR /etc/opendkim
10 | 
11 | COPY opendkim.conf .
12 | COPY TrustedHosts .
13 | 
14 | RUN printf "*.$SMF_EMAILDOMAIN\n" >> TrustedHosts
15 | RUN printf "*@$SMF_EMAILDOMAIN mail._domainkey.$SMF_EMAILDOMAIN\n" >> SigningTable
16 | RUN printf "mail._domainkey.$SMF_EMAILDOMAIN $SMF_EMAILDOMAIN:mail:/etc/opendkim/keys/$SMF_EMAILDOMAIN/mail.private\n" >> KeyTable
17 | RUN mkdir keys    
18 | 
19 | WORKDIR /etc/default
20 | 
21 | RUN printf "SOCKET=\"inet:8891@localhost\"" >> opendkim
22 | 
23 | VOLUME /etc/opendkim/keys
24 | 
25 | WORKDIR /etc/opendkim/keys
26 |         
27 | RUN mkdir $SMF_EMAILDOMAIN && mkdir /var/run/opendkim
28 | 
29 | WORKDIR /etc/opendkim/keys/$SMF_EMAILDOMAIN
30 | 
31 | EXPOSE 25
32 | EXPOSE 110
33 | EXPOSE 995
34 | EXPOSE 993
35 | EXPOSE 143
36 | EXPOSE 465
37 | EXPOSE 587
38 | EXPOSE 4190
39 | 
40 | WORKDIR /etc/postfix/
41 | RUN printf "milter_protocol = 6\n" >> main.cf && \
42 |     printf "milter_default_action = accept\n" >> main.cf && \
43 |     printf "smtpd_milters = inet:localhost:8891\n" >> main.cf && \
44 |     printf "non_smtpd_milters = inet:localhost:8891\n" >> main.cf
45 | 
46 | RUN mkdir -p /var/log/supervisor && \
47 |     mkdir /var/log/supervisor/conf.d
48 |     
49 | WORKDIR /etc/supervisor/conf.d
50 | COPY supervisord.conf .
51 |     
52 | #ENTRYPOINT ["/usr/bin/supervisord"]
53 | CMD ["/usr/sbin/opendkim -x /etc/opendkim/opendkim.conf"]
54 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/View/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="ReflectionEmitClassGeneration.View.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 5 |         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |         xmlns:viewmodel="clr-namespace:ReflectionEmitClassGeneration.ViewModel"
 7 |         mc:Ignorable="d"
 8 |         Title="ReflectionEmitClassGeneration" Height="450" Width="800">
 9 |     <Window.DataContext>
10 |         <viewmodel:MainWindowViewModel/>
11 |     </Window.DataContext>
12 |     <Grid>
13 |         <Grid.RowDefinitions>
14 |             <RowDefinition Height="*"/>
15 |             <RowDefinition Height="35"/>
16 |             <RowDefinition Height="35"/>
17 |         </Grid.RowDefinitions>
18 |         <Grid.ColumnDefinitions>
19 |             <ColumnDefinition/>
20 |             <ColumnDefinition/>
21 |         </Grid.ColumnDefinitions>
22 |         <DataGrid Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"  Margin="5,5,5,5" ItemsSource="{Binding Items, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
23 |                   CanUserAddRows="False" CanUserDeleteRows="False" ColumnWidth="*" GridLinesVisibility="All">
24 |         </DataGrid>
25 | 
26 |         <TextBox Grid.Row="1" Grid.Column="0" Text="{Binding NewPropertyName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" ></TextBox>
27 |         <Button Grid.Row="1" Grid.Column="1" Command="{Binding GenerateItemCommand}" CommandParameter="{Binding NewPropertyName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">Add Property</Button>
28 |     </Grid>
29 | </Window>
30 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/TPLDataflowProcessing.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.29411.108
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TPLDataflowProcessing", "TPLDataflowProcessing.csproj", "{6F1C1BF7-46D9-4401-8C7A-E0D0CFE420C5}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Common.Wpf", "..\Common.Wpf\Common.Wpf.csproj", "{DAD4476B-351A-46EE-9D14-EF3902F18E75}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Any CPU = Debug|Any CPU
13 | 		Release|Any CPU = Release|Any CPU
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{6F1C1BF7-46D9-4401-8C7A-E0D0CFE420C5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{6F1C1BF7-46D9-4401-8C7A-E0D0CFE420C5}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{6F1C1BF7-46D9-4401-8C7A-E0D0CFE420C5}.Release|Any CPU.ActiveCfg = Release|Any CPU
19 | 		{6F1C1BF7-46D9-4401-8C7A-E0D0CFE420C5}.Release|Any CPU.Build.0 = Release|Any CPU
20 | 		{DAD4476B-351A-46EE-9D14-EF3902F18E75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{DAD4476B-351A-46EE-9D14-EF3902F18E75}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{DAD4476B-351A-46EE-9D14-EF3902F18E75}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{DAD4476B-351A-46EE-9D14-EF3902F18E75}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {7625D392-52B8-4A05-86AF-68EC73AC5669}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/react-native-firebase-socialauth/FacebookProvider.js:
--------------------------------------------------------------------------------
 1 | import React, { Component } from 'react';
 2 | import { Button } from 'react-native'
 3 | import { AccessToken, LoginManager, GraphRequest, GraphRequestManager } from 'react-native-fbsdk';
 4 | import auth from '@react-native-firebase/auth';
 5 | import LoginFunctions from './LoginFunctions';
 6 | 
 7 | export default class FacebookProvider extends Component {
 8 |   constructor(props) {
 9 |     super(props)
10 |   }
11 | 
12 |   render() {
13 |     return (
14 |       <Button
15 |         title="Facebook Sign-In"
16 |         onPress={() => {
17 |           onFacebookButtonPress();
18 |         }}
19 |       />
20 |     )
21 |   }
22 | }
23 | 
24 | async function onFacebookButtonPress() {
25 |   try {
26 |     const result = await LoginManager.logInWithPermissions(['public_profile', 'email']);
27 | 
28 |     if (result.isCancelled) {
29 |           console.log('User cancelled the login process');
30 |       return;
31 |     };
32 | 
33 |     let credential;
34 |     _responseInfoCallback = (error, result) => {
35 |       if (error) {
36 |         console.log(error.message);
37 |       } else {
38 |         return LoginFunctions.signInOrLink(auth.FacebookAuthProvider.PROVIDER_ID, credential, result.email);
39 |       }
40 |     }
41 | 
42 |     let token = await AccessToken.getCurrentAccessToken();
43 |     if (!token) {
44 |       throw 'Something went wrong obtaining access token';
45 |     }
46 |     credential = auth.FacebookAuthProvider.credential(token.accessToken);
47 | 
48 |     const infoRequest = new GraphRequest('/me?fields=name,email', null, _responseInfoCallback);
49 |     new GraphRequestManager().addRequest(infoRequest).start();
50 |   }
51 |   catch (error) {
52 |     console.log(error.message)
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/ReflectionEmitClassGeneration.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.29411.108
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ReflectionEmitClassGeneration", "ReflectionEmitClassGeneration.csproj", "{18A83D6A-D546-46A7-9D11-93B003A4F020}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Common.Wpf", "..\Common.Wpf\Common.Wpf.csproj", "{28D09CD8-3BA5-45D6-A81A-09FC5CF37E8D}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Any CPU = Debug|Any CPU
13 | 		Release|Any CPU = Release|Any CPU
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{18A83D6A-D546-46A7-9D11-93B003A4F020}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{18A83D6A-D546-46A7-9D11-93B003A4F020}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{18A83D6A-D546-46A7-9D11-93B003A4F020}.Release|Any CPU.ActiveCfg = Release|Any CPU
19 | 		{18A83D6A-D546-46A7-9D11-93B003A4F020}.Release|Any CPU.Build.0 = Release|Any CPU
20 | 		{28D09CD8-3BA5-45D6-A81A-09FC5CF37E8D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{28D09CD8-3BA5-45D6-A81A-09FC5CF37E8D}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{28D09CD8-3BA5-45D6-A81A-09FC5CF37E8D}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{28D09CD8-3BA5-45D6-A81A-09FC5CF37E8D}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {A5A37B24-EFC6-4FD1-AB09-7E3DF817341F}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/Model/MockPriceFeed.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading.Tasks;
 3 | 
 4 | namespace TPLDataflowProcessing.Model
 5 | {
 6 |     public class MockPriceFeed
 7 |     {
 8 |         public class PriceEventArgs : EventArgs
 9 |         {
10 |             public PriceEventArgs(string name, decimal price)
11 |             {
12 |                 TimeStampUtc = DateTime.UtcNow;
13 |                 Price = price;
14 |                 Name = string.Intern(name);
15 |             }
16 |             public DateTime TimeStampUtc { get; }
17 |             public decimal Price { get; }
18 |             public string Name { get; }
19 |         }
20 | 
21 |         public delegate void PriceEvent(MockPriceFeed sender, PriceEventArgs e);
22 |         public event PriceEvent OnNextPricePublished;
23 |         
24 |         
25 |         private decimal _lastPrice;
26 |         private Random _rand = new Random();
27 |         private object _feedLock = new object();
28 |         private bool _isRunning = false;
29 | 
30 |         public MockPriceFeed(string feedName)
31 |         {
32 |             FeedName = feedName;
33 |             _lastPrice = _rand.Next(0, 100);
34 |         }
35 | 
36 |         public string FeedName { get; }
37 | 
38 |         public async void StartAsync()
39 |         {
40 |             lock (_feedLock)
41 |             {
42 |                 if (_isRunning) return;
43 |                 _isRunning = true;
44 |             }
45 | 
46 |             while (_isRunning)
47 |             {
48 |                 _lastPrice = Math.Abs(_lastPrice + (_rand.Next(-5, 5) / 100m));
49 |                 var priceObj = new PriceEventArgs(FeedName, _lastPrice);
50 |                 OnNextPricePublished(this, priceObj);
51 |                 await Task.Delay(100);
52 |             }
53 |         }
54 | 
55 |         public void Stop()
56 |         {
57 |             lock (_feedLock)
58 |             {
59 |                 if (!_isRunning) return;
60 |                 _isRunning = false;
61 |             }
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/InterviewPrep/LeetCode/find-and-replace-in-string.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | class Solution:
 4 |     def findReplaceString3(self, S: str, indexes: List[int], sources: List[str], targets: List[str]) -> str:
 5 |         result = ''
 6 |         i = 0
 7 |         while i < len(S):
 8 |             if i in indexes:
 9 |                 thisI = indexes.index(i)
10 |                 source = sources[thisI]
11 |                 sourceLen = len(source)
12 |                 if S[i:(i+sourceLen)] == source:
13 |                     result = result + targets[thisI]
14 |                     i = i + sourceLen
15 |                 else:
16 |                     result += S[i:i+1]
17 |                     i = i + 1
18 |             else:
19 |                 result += S[i:i+1]
20 |                 i = i + 1
21 |         return result
22 | 
23 |     def findReplaceString2(self, S: str, indexes: List[int], sources: List[str], targets: List[str]) -> str:
24 |         result = ''
25 |         i = 0
26 |         while i < len(S):
27 |             if i in indexes and S[i:(i+len(sources[indexes.index(i)]))] == sources[indexes.index(i)]:
28 |                 result = result + targets[indexes.index(i)]
29 |                 i = i + len(sources[indexes.index(i)])
30 |             else:
31 |                 result += S[i:i+1]
32 |                 i = i + 1
33 |         return result
34 |         
35 |     def findReplaceString1(self, S: str, indexes: List[int], sources: List[str], targets: List[str]) -> str:
36 |         toReplace = {}
37 |         for i in range(len(indexes)):
38 |             if S[indexes[i]:(indexes[i]+len(sources[i]))] == sources[i]:
39 |                 toReplace[indexes[i]] = [sources[i], targets[i]]
40 |         result = ''
41 |         i = 0
42 |         while i < len(S):
43 |             if i in toReplace.keys():
44 |                 result = result + toReplace[i][1]
45 |                 i = i + len(toReplace[i][0])
46 |             else:
47 |                 result += S[i:i+1]
48 |                 i = i + 1
49 |         return result
50 | 
51 | 
52 | 
53 | sol = Solution()
54 | result = sol.findReplaceString("abcd",[0, 2],["a", "cd"],["eee", "ffff"])
55 | print(result)


--------------------------------------------------------------------------------
/TPLDataflowProcessing/ViewModel/PriceEventViewModel.cs:
--------------------------------------------------------------------------------
 1 | using Common.Wpf.ViewModel;
 2 | using System;
 3 | 
 4 | namespace TPLDataflowProcessing.ViewModel
 5 | {
 6 |     public class PriceEventViewModel : ViewModelBase
 7 |     {
 8 |         private DateTime _timeStampUtc;
 9 |         private decimal _price;
10 |         private decimal _high;
11 |         private decimal _low;
12 | 
13 |         public PriceEventViewModel(string name, DateTime timeStampUtc, decimal price, decimal low, decimal high)
14 |         {
15 |             Name = name;
16 |             Price = price;
17 |             High = high;
18 |             Low = low;
19 |             TimeStampUtc = timeStampUtc;
20 |         }
21 | 
22 |         public void Update(PriceEventViewModel v)
23 |         {
24 |             Price = v.Price;
25 |             High = v.High;
26 |             Low = v.Low;
27 |             TimeStampUtc = v.TimeStampUtc;
28 | 
29 |         }
30 | 
31 |         public string Name { get; }
32 | 
33 |         public DateTime TimeStampUtc
34 |         {
35 |             get
36 |             {
37 |                 return _timeStampUtc;
38 |             }
39 |             set
40 |             {
41 |                 _timeStampUtc = value;
42 |                 NotifyPropertyChanged();
43 |             }
44 |         }
45 | 
46 |         public decimal Low
47 |         {
48 |             get
49 |             {
50 |                 return _low;
51 |             }
52 |             set
53 |             {
54 |                 _low = value;
55 |                 NotifyPropertyChanged();
56 |             }
57 |         }
58 | 
59 |         public decimal High
60 |         {
61 |             get
62 |             {
63 |                 return _high;
64 |             }
65 |             set
66 |             {
67 |                 _high = value;
68 |                 NotifyPropertyChanged();
69 |             }
70 |         }
71 | 
72 |         public decimal Price
73 |         {
74 |             get
75 |             {
76 |                 return _price;
77 |             }
78 |             set
79 |             {
80 |                 _price = value;
81 |                 NotifyPropertyChanged();
82 |             }
83 |         }
84 | 
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/react-native-firebase-socialauth/LoginFunctions.js:
--------------------------------------------------------------------------------
 1 | import auth from '@react-native-firebase/auth';
 2 | import { AsyncStorage } from '@react-native-community/async-storage';
 3 | 
 4 | const LoginFunctions = {
 5 | 
 6 |   signInOrLink: async function (provider, credential, email) {
 7 |     this.saveCredential(provider, credential)
 8 |     await auth().signInWithCredential(credential).catch(
 9 |       async (error) => {
10 |         try {
11 |           if (error.code != "auth/account-exists-with-different-credential") {
12 |             throw error;
13 |           }
14 |           let methods = await auth().fetchSignInMethodsForEmail(email);
15 |           let oldCred = await this.getCredential(methods[0]);
16 |           let prevUser = await auth().signInWithCredential(oldCred);
17 |           auth().currentUser.linkWithCredential(credential);
18 |         }
19 |         catch (error) {
20 |           throw error;
21 |         }
22 |       }
23 |     );
24 |   },
25 | 
26 |   registerOrLink: async function (provider, credential, email) {
27 |     this.saveCredential(provider, credential)
28 |     let user = await auth().createUserWithEmailAndPassword(credential.token, credential.secret).catch(
29 |       async (error) => {
30 |         try {
31 |           if (error.code != "auth/email-already-in-use") {
32 |             throw error;
33 |           }
34 |           let methods = await auth().fetchSignInMethodsForEmail(email);
35 |           let oldCred = await this.getCredential(methods[0]);
36 |           let prevUser = await auth().signInWithCredential(oldCred);
37 |           auth().currentUser.linkWithCredential(credential);
38 |         }
39 |         catch (error) {
40 |           throw error;
41 |         }
42 |       }
43 |     );
44 |     await user.sendEmailVerification();
45 |   },
46 | 
47 |   getCredential: async function (provider) {
48 |     try {
49 |       let value = await AsyncStorage.getItem(provider);
50 |       if (value !== null) {
51 |         let [token, secret] = JSON.parse(value);
52 |         return this.getProvider(provider).credential(token, secret);
53 |       }
54 |     } catch (error) {
55 |       throw error;
56 |     }
57 |   },
58 | 
59 |   saveCredential: async function (provider, credential) {
60 |     try {
61 |       let saveData = JSON.stringify([credential.token, credential.secret])
62 |       await AsyncStorage.setItem(
63 |         provider,
64 |         saveData
65 |       );
66 |     } catch (error) {
67 |       throw error;
68 |     }
69 | 
70 |   },
71 | 
72 |   getProvider: function (providerId) {
73 |     switch (providerId) {
74 |       case auth.GoogleAuthProvider.PROVIDER_ID:
75 |         return auth.GoogleAuthProvider;
76 |       case auth.FacebookAuthProvider.PROVIDER_ID:
77 |         return auth.FacebookAuthProvider;
78 |       case auth.TwitterAuthProvider.PROVIDER_ID:
79 |         return auth.TwitterAuthProvider;
80 |       case auth.EmailAuthProvider.PROVIDER_ID:
81 |         return auth.EmailAuthProvider;
82 |       default:
83 |         throw new Error(`No provider implemented for ${providerId}`);
84 |     }
85 |   },
86 | }
87 | export default LoginFunctions;


--------------------------------------------------------------------------------
/TPLDataflowProcessing/View/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="TPLDataflowProcessing.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 5 |         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 6 |         xmlns:viewmodel="clr-namespace:TPLDataflowProcessing.ViewModel"
 7 |         mc:Ignorable="d"
 8 |         Title="TPL Dataflow Processing" Height="450" Width="900">
 9 |     <Window.DataContext>
10 |         <viewmodel:MainWindowViewModel/>
11 |     </Window.DataContext>
12 |     <Grid>
13 |         <Grid.RowDefinitions>
14 |             <RowDefinition Height="35"/>
15 |             <RowDefinition Height="*"/>
16 |             <RowDefinition Height="35"/>
17 |         </Grid.RowDefinitions>
18 |         <Grid.ColumnDefinitions>
19 |             <ColumnDefinition Width="*"/>
20 |             <ColumnDefinition Width="*"/>
21 |             <ColumnDefinition Width="*"/>
22 |         </Grid.ColumnDefinitions>
23 |         <Label Grid.Row="0"
24 |                Grid.Column="0"
25 |                Content="Feed Log"/>
26 |         <Label Grid.Row="0"
27 |                Grid.Column="1"
28 |                Content="5 Update Intervals"/>
29 |         <Label Grid.Row="0"
30 |                Grid.Column="2"
31 |                Content="1 Second Intervals"/>
32 |         <ListView Grid.Row="1"
33 |                   Grid.Column="0"
34 |                   ItemsSource="{Binding UpdateLog}" />
35 |         <DataGrid Grid.Row="1"
36 |                   Grid.Column="1"
37 |                   ItemsSource="{Binding AveragePrices}" AutoGenerateColumns="False">
38 |             <DataGrid.Columns>
39 |                 <DataGridTextColumn Header="Name" Binding="{Binding Name}"/>
40 |                 <DataGridTextColumn Header="TimeStamp" Binding="{Binding TimeStampUtc}"/>
41 |                 <DataGridTextColumn Header="Low" Binding="{Binding Low}"/>
42 |                 <DataGridTextColumn Header="High" Binding="{Binding High}"/>
43 |                 <DataGridTextColumn Header="Avg" Binding="{Binding Price}"/>
44 |             </DataGrid.Columns>
45 |         </DataGrid>
46 |         <DataGrid Grid.Row="1"
47 |                   Grid.Column="2"
48 |                   ItemsSource="{Binding LatestPrices}" AutoGenerateColumns="False">
49 |             <DataGrid.Columns>
50 |                 <DataGridTextColumn Header="Name" Binding="{Binding Name}" SortDirection="Ascending" SortMemberPath="Name"/>
51 |                 <DataGridTextColumn Header="TimeStamp" Binding="{Binding TimeStampUtc}"/>
52 |                 <DataGridTextColumn Header="Low" Binding="{Binding Low}"/>
53 |                 <DataGridTextColumn Header="High" Binding="{Binding High}"/>
54 |                 <DataGridTextColumn Header="Latest" Binding="{Binding Price}"/>
55 |             </DataGrid.Columns>
56 |         </DataGrid>
57 |         <Button Grid.Row="2"
58 |                 Grid.Column="1"
59 |                 Command="{Binding StartFeedsCommand}">Start Feeds</Button>
60 |         <Button Grid.Row="2"
61 |                 Grid.Column="2"
62 |                 Command="{Binding StopFeedsCommand}">Stop Feeds</Button>
63 |     </Grid>
64 | </Window>
65 | 


--------------------------------------------------------------------------------
/InterviewPrep/Codility/Palladium2020/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace Palladium2020
 4 | {
 5 |     class Program
 6 |     {
 7 |         static void Main(string[] args)
 8 |         {
 9 |             var H = new[] { 1, 1, 7, 6, 6, 6 };
10 |             var ans = solution(H);
11 | 
12 |         }
13 | 
14 |         // Second go at solution, using an array to hold the max seen hight at any position
15 |         public static int solution(int[] H)
16 |         {
17 |             if (H.Length == 0)
18 |                 return 0;
19 |             else if (H.Length == 1)
20 |                 return H[0];
21 |             else
22 |             {
23 |                 var bestResult = int.MaxValue;
24 |                 var maxArray1 = new int[H.Length];
25 |                 var maxArray2 = new int[H.Length];
26 |                 var maxArray1Total = 0;
27 |                 var maxArray2Total = 0;
28 |                 {
29 |                     var maxSeen1 = int.MinValue;
30 |                     var maxSeen2 = int.MinValue;
31 |                     for (int i = 0; i < H.Length; i++)
32 |                     {
33 |                         if (H[i] > maxSeen1)
34 |                             maxSeen1 = H[i];
35 | 
36 |                         if (H[H.Length - i - 1] > maxSeen2)
37 |                             maxSeen2 = H[H.Length - i - 1];
38 | 
39 |                         maxArray1[i] = maxSeen1;
40 |                         maxArray1Total += maxSeen1;
41 | 
42 |                         maxArray2[i] = maxSeen2;
43 |                         maxArray2Total += maxSeen2;
44 |                     }
45 | 
46 |                     // working from left and right, figure out the least required canvas areas
47 |                     for (int i = 0; i < H.Length; i++)
48 |                     {
49 |                         var total1 = (maxArray1[i] * (i + 1)) + (maxArray1[H.Length - 1] * (H.Length - i - 1));
50 |                         var total2 = (maxArray2[i] * (i + 1)) + (maxArray2[H.Length - 1] * (H.Length - i - 1));
51 |                         if (total1 < bestResult)
52 |                             bestResult = total1;
53 |                         if (total2 < bestResult)
54 |                             bestResult = total2;
55 |                     }
56 |                     return bestResult;
57 |                 }
58 |             }
59 |         }
60 | 
61 |         // Brute force answer at every position
62 |         public static int solution1(int[] H)
63 |         {
64 |             if (H.Length == 0)
65 |                 return 0;
66 |             else if (H.Length == 1)
67 |                 return H[0];
68 |             else
69 |             {
70 |                 var bestResult = -1;
71 |                 for (int i = 0; i < H.Length; i++)
72 |                 {
73 |                     var max1 = Max(H, 0, i);
74 |                     var max2 = Max(H, i + 1, H.Length - 1);
75 |                     var total = (max1 * (i + 1)) + ((max2 * (H.Length - (i + 1))));
76 |                     if (bestResult == -1 || bestResult > total)
77 |                         bestResult = total;
78 |                 }
79 |                 return bestResult;
80 |             }
81 |         }
82 | 
83 |         private static int Max(int[] h, int start, int finish)
84 |         {
85 |             var max = int.MinValue;
86 |             for (int i = start; i < finish + 1; i++)
87 |                 if (max < h[i])
88 |                     max = h[i];
89 |             return max;
90 |         }
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/ViewModel/MainWindowViewModel.cs:
--------------------------------------------------------------------------------
  1 | using ReflectionEmitClassGeneration.Types;
  2 | using System;
  3 | using System.Collections;
  4 | using System.Collections.Generic;
  5 | using System.Linq;
  6 | using System.Threading.Tasks;
  7 | using System.Windows.Input;
  8 | using Common.Wpf.Command;
  9 | using Common.Wpf.ViewModel;
 10 | 
 11 | namespace ReflectionEmitClassGeneration.ViewModel
 12 | {
 13 |     public class MainWindowViewModel : ViewModelBase
 14 |     {
 15 |         private IList items;
 16 |         private Dictionary<string, Type> _properties;
 17 |         private string _newPropertyName;
 18 |         private TypeGeneratorGeneric<ItemViewModelBase> _typeGenerator;
 19 | 
 20 |         private static object _feedLock = new object();
 21 |         private bool _feedRunning;
 22 | 
 23 |         public MainWindowViewModel()
 24 |         {
 25 |             GenerateItemCommand = new GenericCommand(GenerateItems, obj =>
 26 |             {
 27 |                 return !string.IsNullOrEmpty(obj?.ToString()) &&
 28 |                 !_properties.ContainsKey(obj.ToString());
 29 |             });
 30 |             _properties = new Dictionary<string, Type>();
 31 |             _newPropertyName = "Id";
 32 |             GenerateItems();
 33 |             StartDataFeed();
 34 |         }
 35 | 
 36 |         public IList Items
 37 |         {
 38 |             get => items;
 39 |             set
 40 |             {
 41 |                 items = value;
 42 |                 NotifyPropertyChanged();
 43 |             }
 44 |         }
 45 | 
 46 |         public ICommand GenerateItemCommand { get; }
 47 | 
 48 |         public string NewPropertyName
 49 |         {
 50 |             get => _newPropertyName;
 51 |             set
 52 |             {
 53 |                 _newPropertyName = value;
 54 |                 NotifyPropertyChanged();
 55 |             }
 56 |         }
 57 | 
 58 |         public void GenerateItems()
 59 |         {
 60 |             _properties.Add(NewPropertyName, typeof(int));
 61 |             NewPropertyName = null;
 62 |             _typeGenerator = new TypeGeneratorGeneric<ItemViewModelBase>(_properties);
 63 |             var items = new List<ItemViewModelBase>();
 64 |             for (var i = 0; i < 10; i++)
 65 |             {
 66 |                 var newObject = _typeGenerator.CreateInstance(new Dictionary<string, object> { { "Id", i } });
 67 |                 items.Add(newObject);
 68 |             }
 69 | 
 70 |             Items = _typeGenerator.CreateList(items.ToArray());
 71 |         }
 72 | 
 73 |         private async void StartDataFeed()
 74 |         {
 75 |             lock (_feedLock)
 76 |                 _feedRunning = true;
 77 |             while (_feedRunning)
 78 |             {
 79 |                 await Task.Delay(500);
 80 |                 if (_properties.Count() == 1) continue;
 81 |                 lock (_feedLock)
 82 |                 {
 83 |                     foreach (var item in Items)
 84 |                     {
 85 |                         var data = GetRandomData();
 86 |                         var vm = item as ItemViewModelBase;
 87 |                         _typeGenerator.SetValues(vm, data);
 88 |                         foreach (var property in _properties)
 89 |                             vm.NotifyPropertyChanged(property.Key);
 90 | 
 91 | 
 92 |                     }
 93 |                 }
 94 |             }
 95 |         }
 96 | 
 97 |         private Dictionary<string, object> GetRandomData()
 98 |         {
 99 |             var random = new Random();
100 |             var valuesDict = new Dictionary<string, object>();
101 |             foreach (var property in _properties)
102 |             {
103 |                 if (property.Key == "Id") continue;
104 |                 valuesDict.Add(property.Key, random.Next());
105 | 
106 |             }
107 |             return valuesDict;
108 |         }
109 | 
110 |         ~MainWindowViewModel()
111 |         {
112 |             lock (_feedLock)
113 |                 _feedRunning = false;
114 |         }
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/react-native-firebase-socialauth/EmailProvider.js:
--------------------------------------------------------------------------------
  1 | import React, { Component, StyleSheet } from 'react';
  2 | import { Button, TextInput, View, TouchableHighlight, Text } from 'react-native'
  3 | import auth from '@react-native-firebase/auth';
  4 | import LoginFunctions from './LoginFunctions';
  5 | 
  6 | 
  7 | export default class EmailProvider extends Component {
  8 |   state = {
  9 |     email: '',
 10 |     password: '',
 11 |     password2: '',
 12 |     isEmailValid: true,
 13 |     isPasswordValid: true,
 14 |     showRegister: false
 15 |   };
 16 | 
 17 |   constructor(props) {
 18 |     super(props)
 19 |   }
 20 | 
 21 |   render() {
 22 |     return (
 23 |       <View >
 24 |         <TextInput
 25 |           label={"Email"}
 26 |           keyboardType="email-address"
 27 |           placeholder="Email"
 28 |           onChangeText={text => {
 29 |             this.setState({ email: text });
 30 |           }}
 31 |           error={this.state.isEmailValid}
 32 |         />
 33 |         <TextInput
 34 |           label={"Password"}
 35 |           secureTextEntry
 36 |           placeholder="Password"
 37 |           secureTextEntry={true}
 38 |           error={this.state.isPasswordValid}
 39 |           onChangeText={text => {
 40 |             this.setState({ password: text });
 41 |           }} />
 42 |         {this.state.showRegister ?
 43 |           <View>
 44 |             <Button
 45 |               title="Sign-In"
 46 |               onPress={() => {
 47 |                 onEmailSigninButtonPress(this.state.email, this.state.password, this.checkValidEmail);
 48 |               }} />
 49 |             <TouchableHighlight onPress={() => this.toggleRegister()}>
 50 |               <Text>Not registered? Sign up here</Text>
 51 |             </TouchableHighlight>
 52 |           </View> :
 53 |           <View>
 54 |             <TextInput
 55 |               label={"Confirm Password"}
 56 |               secureTextEntry
 57 |               placeholder="Confirm Password"
 58 |               secureTextEntry={true}
 59 |               error={this.state.isPasswordValid}
 60 |               onChangeText={text => {
 61 |                 this.setState({ password2: text });
 62 |               }} />
 63 |             <Button
 64 |               title="Register"
 65 |               onPress={() => {
 66 |                 onEmailRegisterButtonPress(this.state.email, this.state.password,
 67 |                   this.state.password2, this.checkValidEmail, this.checkValidPassword)
 68 |               }} />
 69 |             <TouchableHighlight onPress={() => this.toggleRegister()}>
 70 |               <Text>Go Back</Text>
 71 |             </TouchableHighlight>
 72 |           </View>}
 73 |       </View>)
 74 |   }
 75 | 
 76 |   toggleRegister() {
 77 |     this.setState({ showRegister: !this.state.showRegister });
 78 |   }
 79 | 
 80 |   checkValidEmail = (email) => {
 81 |     const expression = /(?!.*\.{2})^([a-z\d!#$%&'*+\-\/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+(\.[a-z\d!#$%&'*+\-\/=?^_`{|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)*|"((([\t]*\r\n)?[\t]+)?([\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*(([\t]*\r\n)?[\t]+)?")@(([a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|[a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF][a-z\d\-._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]*[a-z\d\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])\.)+([a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|[a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF][a-z\d\-._~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]*[a-z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])\.?$/i; let re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
 82 |     let valid = expression.test(String(email)?.toLowerCase());
 83 |     if (!valid) {
 84 |       console.log('Email is not valid');
 85 |     }
 86 |     return valid;
 87 |   }
 88 | 
 89 |   checkValidPassword = (password, password2) => {
 90 |     let valid = true;
 91 |     if (password.length < 8) {
 92 |       valid = false;
 93 |       console.log('Password is too short')
 94 |     }
 95 |     else if (password != password2) {
 96 |       valid = false;
 97 |       console.log('Passwords do not match')
 98 |     }
 99 |     return valid;
100 |   }
101 | }
102 | 
103 | async function onEmailSigninButtonPress(email, password, checkValidEmail) {
104 | 
105 |   try {
106 |     if (!checkValidEmail(email)) {
107 |       return;
108 |     }
109 |     let credential = auth.EmailAuthProvider.credential(email, password);
110 |     return LoginFunctions.signInOrLink(auth.EmailAuthProvider.PROVIDER_ID, credential, email);
111 |   }
112 |   catch (error) {
113 |     console.log('Login details not recognised');
114 |   }
115 | }
116 | 
117 | async function onEmailRegisterButtonPress(email, password, password2,
118 |   checkValidEmail, checkPasswordValid) {
119 |   try {
120 |     if (!checkValidEmail(email)) {
121 |       return;
122 |     }
123 |     if (!checkPasswordValid(password, password2)) {
124 |       return;
125 |     }
126 | 
127 |     let credential = auth.EmailAuthProvider.credential(email, password);
128 |     return LoginFunctions.registerOrLink(auth.EmailAuthProvider.PROVIDER_ID, credential, email);
129 |   }
130 |   catch (error) {
131 |     console.log(error.message);
132 |   }
133 | 
134 | }


--------------------------------------------------------------------------------
/ReflectionEmitClassGeneration/Types/TypeGenerator.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | using System.Reflection;
  5 | using System.Reflection.Emit;
  6 | 
  7 | namespace ReflectionEmitClassGeneration.Types
  8 | {
  9 |     public class TypeGenerator : TypeGeneratorGeneric<object>
 10 |     {
 11 |         public TypeGenerator(Dictionary<string, Type> properties) : base(properties)
 12 |         {
 13 |         }
 14 |     }
 15 | 
 16 |     /// <summary>
 17 |     /// Generate a new type that uses T as the base class
 18 |     /// </summary>
 19 |     /// <typeparam name="T"></typeparam>
 20 |     public class TypeGeneratorGeneric<T> where T : class
 21 |     {
 22 |         private readonly Dictionary<string, MethodInfo> _setMethods;
 23 | 
 24 |         public TypeGeneratorGeneric(Dictionary<string, Type> properties)
 25 |         {
 26 |             Properties = properties;
 27 |             _setMethods = new Dictionary<string, MethodInfo>();
 28 |             Initialise();
 29 |         }
 30 | 
 31 |         private void Initialise()
 32 |         {
 33 |             var newTypeName = Guid.NewGuid().ToString();
 34 |             var assemblyName = new AssemblyName(newTypeName);
 35 |             var dynamicAssembly = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
 36 |             var dynamicModule = dynamicAssembly.DefineDynamicModule("Main");
 37 |             var dynamicType = dynamicModule.DefineType(newTypeName,
 38 |                     TypeAttributes.Public |
 39 |                     TypeAttributes.Class |
 40 |                     TypeAttributes.AutoClass |
 41 |                     TypeAttributes.AnsiClass |
 42 |                     TypeAttributes.BeforeFieldInit |
 43 |                     TypeAttributes.AutoLayout,
 44 |                     typeof(T));
 45 |             dynamicType.DefineDefaultConstructor(MethodAttributes.Public |
 46 |                                                 MethodAttributes.SpecialName |
 47 |                                                 MethodAttributes.RTSpecialName);
 48 | 
 49 |             foreach (var property in Properties)
 50 |                 AddProperty(dynamicType, property.Key, property.Value);
 51 | 
 52 |             GeneratedType = dynamicType.CreateType();
 53 | 
 54 |             foreach (var property in Properties)
 55 |             {
 56 |                 var propertyInfo = GeneratedType.GetProperty(property.Key);
 57 | 
 58 |                 var setMethod = propertyInfo.GetSetMethod();
 59 |                 if (setMethod == null) continue;
 60 |                 _setMethods.Add(property.Key, setMethod);
 61 |             }
 62 |         }
 63 | 
 64 |         public Type GeneratedType { private set; get; }
 65 | 
 66 |         public Dictionary<string, Type> Properties { get; }
 67 | 
 68 |         private static void AddProperty(TypeBuilder typeBuilder, string propertyName, Type propertyType)
 69 |         {
 70 |             var fieldBuilder = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
 71 |             var propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
 72 |             
 73 |             var getMethod = typeBuilder.DefineMethod("get_" + propertyName,
 74 |                 MethodAttributes.Public |
 75 |                 MethodAttributes.SpecialName |
 76 |                 MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
 77 |             var getMethodIL = getMethod.GetILGenerator();
 78 |             getMethodIL.Emit(OpCodes.Ldarg_0);
 79 |             getMethodIL.Emit(OpCodes.Ldfld, fieldBuilder);
 80 |             getMethodIL.Emit(OpCodes.Ret);
 81 | 
 82 |             var setMethod = typeBuilder.DefineMethod("set_" + propertyName,
 83 |                   MethodAttributes.Public |
 84 |                   MethodAttributes.SpecialName |
 85 |                   MethodAttributes.HideBySig,
 86 |                   null, new[] { propertyType });
 87 |             var setMethodIL = setMethod.GetILGenerator();
 88 |             Label modifyProperty = setMethodIL.DefineLabel();
 89 |             Label exitSet = setMethodIL.DefineLabel();
 90 | 
 91 |             setMethodIL.MarkLabel(modifyProperty);
 92 |             setMethodIL.Emit(OpCodes.Ldarg_0);
 93 |             setMethodIL.Emit(OpCodes.Ldarg_1);
 94 |             setMethodIL.Emit(OpCodes.Stfld, fieldBuilder);
 95 | 
 96 |             setMethodIL.Emit(OpCodes.Nop);
 97 |             setMethodIL.MarkLabel(exitSet);
 98 |             setMethodIL.Emit(OpCodes.Ret);
 99 | 
100 |             propertyBuilder.SetGetMethod(getMethod);
101 |             propertyBuilder.SetSetMethod(setMethod);
102 |         }
103 | 
104 |         /// <summary>
105 |         /// Create a new instance of your generated type
106 |         /// </summary>
107 |         /// <typeparam name="T"></typeparam>
108 |         /// <param name="values"></param>
109 |         /// <returns></returns>
110 |         public T CreateInstance(Dictionary<string, object> values = null)
111 |         {
112 |             var instance = (T)Activator.CreateInstance(GeneratedType);
113 | 
114 |             if (values != null)
115 |                 SetValues(instance, values);
116 | 
117 |             return instance;
118 |         }
119 | 
120 |         /// <summary>
121 |         /// Update the property values on an instance of your generated type
122 |         /// </summary>
123 |         /// <typeparam name="T"></typeparam>
124 |         /// <param name="instance"></param>
125 |         /// <param name="values"></param>
126 |         public void SetValues(T instance, Dictionary<string, object> values)
127 |         {
128 |             foreach (var value in values)
129 |                 SetValue(instance, value.Key, value.Value);
130 |         }
131 | 
132 |         /// <summary>
133 |         /// 
134 |         /// </summary>
135 |         /// <typeparam name="T"></typeparam>
136 |         /// <param name="instance"></param>
137 |         /// <param name="propertyName"></param>
138 |         /// <param name="propertyValue"></param>
139 |         public void SetValue(T instance, string propertyName, object propertyValue)
140 |         {
141 |             if (!_setMethods.TryGetValue(propertyName, out var setter))
142 |                 throw new ArgumentException($"Type does not contain settter for property {propertyName}", nameof(propertyName));
143 |             setter.Invoke(instance, new[] { propertyValue });
144 |         }
145 | 
146 |         /// <summary>
147 |         /// Create a new list of your new type and populate on initialisation
148 |         /// </summary>
149 |         /// <param name="values"></param>
150 |         /// <returns></returns>
151 |         public IList CreateList(T [] values = null)
152 |         {
153 |             var listGenericType = typeof(List<>);
154 |             var list = listGenericType.MakeGenericType(GeneratedType);
155 |             var constructor = list.GetConstructor(new Type[] { });
156 |             var newList = (IList)constructor.Invoke(new object[] { });
157 |             foreach (var value in values)
158 |                 newList.Add(value);
159 |             return newList;
160 |         }
161 |     }
162 | }
163 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.suo
  8 | *.user
  9 | *.userosscache
 10 | *.sln.docstates
 11 | 
 12 | # User-specific files (MonoDevelop/Xamarin Studio)
 13 | *.userprefs
 14 | 
 15 | # Build results
 16 | [Dd]ebug/
 17 | [Dd]ebugPublic/
 18 | [Rr]elease/
 19 | [Rr]eleases/
 20 | x64/
 21 | x86/
 22 | bld/
 23 | [Bb]in/
 24 | [Oo]bj/
 25 | [Ll]og/
 26 | 
 27 | # Visual Studio 2015/2017 cache/options directory
 28 | .vs/
 29 | # Uncomment if you have tasks that create the project's static files in wwwroot
 30 | #wwwroot/
 31 | 
 32 | # Visual Studio 2017 auto generated files
 33 | Generated\ Files/
 34 | 
 35 | # MSTest test Results
 36 | [Tt]est[Rr]esult*/
 37 | [Bb]uild[Ll]og.*
 38 | 
 39 | # NUNIT
 40 | *.VisualState.xml
 41 | TestResult.xml
 42 | 
 43 | # Build Results of an ATL Project
 44 | [Dd]ebugPS/
 45 | [Rr]eleasePS/
 46 | dlldata.c
 47 | 
 48 | # Benchmark Results
 49 | BenchmarkDotNet.Artifacts/
 50 | 
 51 | # .NET Core
 52 | project.lock.json
 53 | project.fragment.lock.json
 54 | artifacts/
 55 | **/Properties/launchSettings.json
 56 | 
 57 | # StyleCop
 58 | StyleCopReport.xml
 59 | 
 60 | # Files built by Visual Studio
 61 | *_i.c
 62 | *_p.c
 63 | *_i.h
 64 | *.ilk
 65 | *.meta
 66 | *.obj
 67 | *.iobj
 68 | *.pch
 69 | *.pdb
 70 | *.ipdb
 71 | *.pgc
 72 | *.pgd
 73 | *.rsp
 74 | *.sbr
 75 | *.tlb
 76 | *.tli
 77 | *.tlh
 78 | *.tmp
 79 | *.tmp_proj
 80 | *.log
 81 | *.vspscc
 82 | *.vssscc
 83 | .builds
 84 | *.pidb
 85 | *.svclog
 86 | *.scc
 87 | 
 88 | # Chutzpah Test files
 89 | _Chutzpah*
 90 | 
 91 | # Visual C++ cache files
 92 | ipch/
 93 | *.aps
 94 | *.ncb
 95 | *.opendb
 96 | *.opensdf
 97 | *.sdf
 98 | *.cachefile
 99 | *.VC.db
100 | *.VC.VC.opendb
101 | 
102 | # Visual Studio profiler
103 | *.psess
104 | *.vsp
105 | *.vspx
106 | *.sap
107 | 
108 | # Visual Studio Trace Files
109 | *.e2e
110 | 
111 | # TFS 2012 Local Workspace
112 | $tf/
113 | 
114 | # Guidance Automation Toolkit
115 | *.gpState
116 | 
117 | # ReSharper is a .NET coding add-in
118 | _ReSharper*/
119 | *.[Rr]e[Ss]harper
120 | *.DotSettings.user
121 | 
122 | # JustCode is a .NET coding add-in
123 | .JustCode
124 | 
125 | # TeamCity is a build add-in
126 | _TeamCity*
127 | 
128 | # DotCover is a Code Coverage Tool
129 | *.dotCover
130 | 
131 | # AxoCover is a Code Coverage Tool
132 | .axoCover/*
133 | !.axoCover/settings.json
134 | 
135 | # Visual Studio code coverage results
136 | *.coverage
137 | *.coveragexml
138 | 
139 | # NCrunch
140 | _NCrunch_*
141 | .*crunch*.local.xml
142 | nCrunchTemp_*
143 | 
144 | # MightyMoose
145 | *.mm.*
146 | AutoTest.Net/
147 | 
148 | # Web workbench (sass)
149 | .sass-cache/
150 | 
151 | # Installshield output folder
152 | [Ee]xpress/
153 | 
154 | # DocProject is a documentation generator add-in
155 | DocProject/buildhelp/
156 | DocProject/Help/*.HxT
157 | DocProject/Help/*.HxC
158 | DocProject/Help/*.hhc
159 | DocProject/Help/*.hhk
160 | DocProject/Help/*.hhp
161 | DocProject/Help/Html2
162 | DocProject/Help/html
163 | 
164 | # Click-Once directory
165 | publish/
166 | 
167 | # Publish Web Output
168 | *.[Pp]ublish.xml
169 | *.azurePubxml
170 | # Note: Comment the next line if you want to checkin your web deploy settings,
171 | # but database connection strings (with potential passwords) will be unencrypted
172 | *.pubxml
173 | *.publishproj
174 | 
175 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
176 | # checkin your Azure Web App publish settings, but sensitive information contained
177 | # in these scripts will be unencrypted
178 | PublishScripts/
179 | 
180 | # NuGet Packages
181 | *.nupkg
182 | # The packages folder can be ignored because of Package Restore
183 | **/[Pp]ackages/*
184 | # except build/, which is used as an MSBuild target.
185 | !**/[Pp]ackages/build/
186 | # Uncomment if necessary however generally it will be regenerated when needed
187 | #!**/[Pp]ackages/repositories.config
188 | # NuGet v3's project.json files produces more ignorable files
189 | *.nuget.props
190 | *.nuget.targets
191 | 
192 | # Microsoft Azure Build Output
193 | csx/
194 | *.build.csdef
195 | 
196 | # Microsoft Azure Emulator
197 | ecf/
198 | rcf/
199 | 
200 | # Windows Store app package directories and files
201 | AppPackages/
202 | BundleArtifacts/
203 | Package.StoreAssociation.xml
204 | _pkginfo.txt
205 | *.appx
206 | 
207 | # Visual Studio cache files
208 | # files ending in .cache can be ignored
209 | *.[Cc]ache
210 | # but keep track of directories ending in .cache
211 | !*.[Cc]ache/
212 | 
213 | # Others
214 | ClientBin/
215 | ~$*
216 | *~
217 | *.dbmdl
218 | *.dbproj.schemaview
219 | *.jfm
220 | *.pfx
221 | *.publishsettings
222 | orleans.codegen.cs
223 | 
224 | # Including strong name files can present a security risk 
225 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
226 | #*.snk
227 | 
228 | # Since there are multiple workflows, uncomment next line to ignore bower_components
229 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
230 | #bower_components/
231 | 
232 | # RIA/Silverlight projects
233 | Generated_Code/
234 | 
235 | # Backup & report files from converting an old project file
236 | # to a newer Visual Studio version. Backup files are not needed,
237 | # because we have git ;-)
238 | _UpgradeReport_Files/
239 | Backup*/
240 | UpgradeLog*.XML
241 | UpgradeLog*.htm
242 | ServiceFabricBackup/
243 | *.rptproj.bak
244 | 
245 | # SQL Server files
246 | *.mdf
247 | *.ldf
248 | *.ndf
249 | 
250 | # Business Intelligence projects
251 | *.rdl.data
252 | *.bim.layout
253 | *.bim_*.settings
254 | *.rptproj.rsuser
255 | 
256 | # Microsoft Fakes
257 | FakesAssemblies/
258 | 
259 | # GhostDoc plugin setting file
260 | *.GhostDoc.xml
261 | 
262 | # Node.js Tools for Visual Studio
263 | .ntvs_analysis.dat
264 | node_modules/
265 | 
266 | # Visual Studio 6 build log
267 | *.plg
268 | 
269 | # Visual Studio 6 workspace options file
270 | *.opt
271 | 
272 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
273 | *.vbw
274 | 
275 | # Visual Studio LightSwitch build output
276 | **/*.HTMLClient/GeneratedArtifacts
277 | **/*.DesktopClient/GeneratedArtifacts
278 | **/*.DesktopClient/ModelManifest.xml
279 | **/*.Server/GeneratedArtifacts
280 | **/*.Server/ModelManifest.xml
281 | _Pvt_Extensions
282 | 
283 | # Paket dependency manager
284 | .paket/paket.exe
285 | paket-files/
286 | 
287 | # FAKE - F# Make
288 | .fake/
289 | 
290 | # JetBrains Rider
291 | .idea/
292 | *.sln.iml
293 | 
294 | # CodeRush
295 | .cr/
296 | 
297 | # Python Tools for Visual Studio (PTVS)
298 | __pycache__/
299 | *.pyc
300 | 
301 | # Cake - Uncomment if you are using it
302 | # tools/**
303 | # !tools/packages.config
304 | 
305 | # Tabs Studio
306 | *.tss
307 | 
308 | # Telerik's JustMock configuration file
309 | *.jmconfig
310 | 
311 | # BizTalk build output
312 | *.btp.cs
313 | *.btm.cs
314 | *.odx.cs
315 | *.xsd.cs
316 | 
317 | # OpenCover UI analysis results
318 | OpenCover/
319 | 
320 | # Azure Stream Analytics local run output 
321 | ASALocalRun/
322 | 
323 | # MSBuild Binary and Structured Log
324 | *.binlog
325 | 
326 | # NVidia Nsight GPU debugger configuration file
327 | *.nvuser
328 | 
329 | # MFractors (Xamarin productivity tool) working folder 
330 | .mfractor/
331 | 


--------------------------------------------------------------------------------
/TPLDataflowProcessing/ViewModel/MainWindowViewModel.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Collections.ObjectModel;
  4 | using System.Linq;
  5 | using System.Text;
  6 | using TPLDataflowProcessing.Model;
  7 | using Common.Wpf.Command;
  8 | using Common.Wpf.ViewModel;
  9 | using static TPLDataflowProcessing.Model.MockPriceFeed;
 10 | using System.Threading.Tasks.Dataflow;
 11 | using System.Timers;
 12 | 
 13 | namespace TPLDataflowProcessing.ViewModel
 14 | {
 15 |     public class MainWindowViewModel : ViewModelBase
 16 |     {
 17 |         private IList<string> _stocks = new[] { "FB", "AAPL", "AMZN", "NFLX", "GOOG" };
 18 |         //private IList<string> stocks = new[] { "FB" };
 19 |         private const int _maxLogSize = 20;
 20 |         private IDictionary<string, MockPriceFeed> _priceFeeds = new Dictionary<string, MockPriceFeed>();
 21 |         private bool _feedsStarted = false;
 22 | 
 23 |         public MainWindowViewModel()
 24 |         {
 25 |             _updateLog = new ObservableCollection<string>();
 26 |             _latestPrices = new ObservableCollection<PriceEventViewModel>();
 27 |             _latestPriceDict = new Dictionary<string, PriceEventViewModel>();
 28 |             _averagePrices = new ObservableCollection<PriceEventViewModel>();
 29 |             _averagePriceDict = new Dictionary<string, PriceEventViewModel>();
 30 | 
 31 |             StartFeedsCommand = new GenericCommand(() => StartStopFeeds(true), _ => !_feedsStarted);
 32 |             StopFeedsCommand = new GenericCommand(() => StartStopFeeds(false), _ => _feedsStarted);
 33 | 
 34 |             Init();
 35 |         }
 36 | 
 37 |         private void Init()
 38 |         {
 39 |             _bufferBlock = new BufferBlock<PriceEventArgs>();
 40 |             _broadcastBlock = new BroadcastBlock<PriceEventArgs>(e => e);
 41 |             _bufferBlock.LinkTo(_broadcastBlock);
 42 | 
 43 |             foreach (var stock in _stocks)
 44 |             {
 45 |                 var feed = new MockPriceFeed(stock);
 46 |                 _priceFeeds.Add(stock, feed);
 47 |                 feed.OnNextPricePublished += Feed_OnNextPricePublished;
 48 |             }
 49 |             InitUILog();
 50 |             InitUIAverage();
 51 |             InitUILatestPriceTimeInterval();
 52 | 
 53 |         }
 54 | 
 55 |         private void InitUIAverage()
 56 |         {
 57 |             foreach (var feed in _priceFeeds)
 58 |             {
 59 |                 var batchBlock = new BatchBlock<PriceEventArgs>(5);
 60 |                 var actionBlock = new ActionBlock<PriceEventArgs[]>(e =>
 61 |                 {
 62 |                     var average = e.Average(v => v.Price);
 63 |                     var low = e.Min(v => v.Price);
 64 |                     var high = e.Max(v => v.Price);
 65 |                     var update = new PriceEventViewModel(feed.Key, DateTime.UtcNow, average, low, high);
 66 |                     UpdatePrice(update, _averagePriceDict, AveragePrices);
 67 |                 });
 68 | 
 69 |                 _broadcastBlock.LinkTo(batchBlock, p => p.Name == feed.Key);
 70 |                 batchBlock.LinkTo(actionBlock);
 71 |             }
 72 |         }
 73 | 
 74 |         private void InitUILatestPriceTimeInterval()
 75 |         {
 76 |             foreach (var feed in _priceFeeds)
 77 |             {
 78 |                 var batchBlock = new BatchBlock<PriceEventArgs>(10000);
 79 |                 var intervalTimer = new Timer(1000);
 80 |                 intervalTimer.Elapsed += (s, e) => batchBlock.TriggerBatch();
 81 | 
 82 |                 var updateUILatestPrice = new ActionBlock<PriceEventArgs[]>(e =>
 83 |                 {
 84 |                     var latest = e.OrderByDescending(o => o.TimeStampUtc)
 85 |                         .FirstOrDefault();
 86 |                     var low = e.Min(v => v.Price);
 87 |                     var high = e.Max(v => v.Price);
 88 |                     var update = new PriceEventViewModel(feed.Key, DateTime.UtcNow, latest.Price, low, high);
 89 | 
 90 |                     UpdatePrice(update, _latestPriceDict, LatestPrices);
 91 |                 });
 92 | 
 93 |                 _broadcastBlock.LinkTo(batchBlock, p => p.Name == feed.Key);
 94 |                 batchBlock.LinkTo(updateUILatestPrice);
 95 |                 intervalTimer.Start();
 96 |             }
 97 |         }
 98 | 
 99 |         private void UpdatePrice(PriceEventViewModel v, Dictionary<string, PriceEventViewModel> dictToUpdate,
100 |             ObservableCollection<PriceEventViewModel> collectionToUpdate)
101 |         {
102 |             if (App.Current != null)
103 |                 App.Current.Dispatcher.Invoke(() =>
104 |                 {
105 |                     if (dictToUpdate.TryGetValue(v.Name, out var lastPrice))
106 |                         lastPrice.Update(v);
107 |                     else
108 |                     {
109 |                         dictToUpdate.Add(v.Name, v);
110 |                         collectionToUpdate.Add(v);
111 |                     }
112 |                 });
113 |         }
114 | 
115 |         private void InitUILog()
116 |         {
117 |             var transformToText = new TransformBlock<PriceEventArgs, string>(e =>
118 |             {
119 |                 return $"{e.TimeStampUtc} {e.Name}: {e.Price}";
120 |             });
121 | 
122 |             var updateUILog = new ActionBlock<string>(e =>
123 |             {
124 |                 if (App.Current != null)
125 |                     App.Current.Dispatcher.Invoke(() =>
126 |                     {
127 |                         if (UpdateLog.Count() == _maxLogSize)
128 |                             UpdateLog.RemoveAt(_maxLogSize - 1);
129 |                         UpdateLog.Insert(0, e);
130 |                     });
131 |             });
132 | 
133 |             _broadcastBlock.LinkTo(transformToText);
134 |             transformToText.LinkTo(updateUILog);
135 |         }
136 | 
137 |         private void StartStopFeeds(bool start)
138 |         {
139 |             _feedsStarted = start;
140 |             foreach (var feed in _priceFeeds)
141 |                 if (start)
142 |                     feed.Value.StartAsync();
143 |                 else
144 |                     feed.Value.Stop();
145 |         }
146 | 
147 |         public GenericCommand StartFeedsCommand { get; set; }
148 |         public GenericCommand StopFeedsCommand { get; set; }
149 |         
150 |         private BroadcastBlock<PriceEventArgs> _broadcastBlock;
151 |         private BufferBlock<PriceEventArgs> _bufferBlock;
152 | 
153 |         private ObservableCollection<string> _updateLog;
154 |         public ObservableCollection<string> UpdateLog 
155 |         {
156 |             get => _updateLog; 
157 |             set 
158 |             {
159 |                 _updateLog = value;
160 |                 NotifyPropertyChanged();
161 |             }
162 |         }
163 | 
164 |         Dictionary<string, PriceEventViewModel> _averagePriceDict;
165 |         private ObservableCollection<PriceEventViewModel> _averagePrices;
166 |         public ObservableCollection<PriceEventViewModel> AveragePrices
167 |         {
168 |             get => _averagePrices;
169 |             set
170 |             {
171 |                 _averagePrices = value;
172 |                 NotifyPropertyChanged();
173 |             }
174 |         }
175 | 
176 |         Dictionary<string, PriceEventViewModel> _latestPriceDict;
177 |         private ObservableCollection<PriceEventViewModel> _latestPrices;
178 |         public ObservableCollection<PriceEventViewModel> LatestPrices
179 |         {
180 |             get => _latestPrices;
181 |             set
182 |             {
183 |                 _latestPrices = value;
184 |                 NotifyPropertyChanged();
185 |             }
186 |         }
187 | 
188 |         private void Feed_OnNextPricePublished(MockPriceFeed sender, PriceEventArgs e)
189 |         {
190 |             _bufferBlock.Post(e);
191 |         }
192 | 
193 |         ~MainWindowViewModel()
194 |         {
195 |             StartStopFeeds(false);
196 |         }
197 |     }
198 | }
199 | //


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------