Add Debian package

.github/workflows/c-cpp.yml

@@ -15,11 +15,7 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install PostgreSQL development tools
       run: sudo apt install postgresql-server-dev-13
-#     - name: configure
-#       run: ./configure
-    - name: make
+    - name: Make
       run: make
-#     - name: make check
-#       run: make check
-#     - name: make distcheck
-#       run: make distcheck
+    # - name: Install
+    #   run: sudo make install

README.md

@@ -1,23 +1,34 @@
-# PostgreSQL-IBAN
+![C/C++ CI](https://github.com/yorickdewid/PostgreSQL-IBAN/workflows/C/C++%20CI/badge.svg)
+
+# PostgreSQL IBAN
 PostgreSQL IBAN extension that can verify International Bank Account Numbers.
 This ensures that only valid bank account numbers are stored. 
 
 ### Example
 ```sql
 CREATE TABLE test_iban (
-  id serial NOT NULL,
-  name character varying(32),
-  account iban,
-  CONSTRAINT test_iban_pkey PRIMARY KEY (id)
+  name text,
+  account iban
 )
 
+--
 -- Insert data
-INSERT INTO test_iban (name, account) VALUES ('John', 'NL91ABNA0417164300'); -- Dutch IBAN format
-INSERT INTO test_iban (name, account) VALUES ('Doe', 'DE89370400440532013000'); -- German IBAN format
+--
 
--- Invalid bank account
+-- Dutch IBAN format
+INSERT INTO test_iban (name, account) VALUES ('John', 'NL91ABNA0417164300');
+-- German IBAN format
+INSERT INTO test_iban (name, account) VALUES ('Doe', 'DE89370400440532013000');
+
+-- Invalid data
 INSERT INTO test_iban (name, account) VALUES ('Dean', 'AZ22NABZ00000000137010001944');
 
+--
+-- Show output
+--
+
+SELECT * FROM test_iban;
+
 ```
 
 Manually test input
@@ -31,3 +42,19 @@ the `::iban` datatype can be cast to an text to perform string operations
 ```sql
 SELECT 'KZ86125KZT5004100100'::iban::text;
 ```
+
+## Build
+
+Make sure PostgreSQL development tools are installed (check `pg_config`)
+
+```bash
+git clone https://github.com/yorickdewid/PostgreSQL-IBAN
+cd PostgreSQL-IBAN
+make install
+```
+
+Login to the database and load the extension
+
+```sql
+CREATE EXTENSION iban;
+```

debian/changelog

@@ -0,0 +1,5 @@
+postgresql-iban (1.0.0~git15.g0e533af-1) bookworm; urgency=medium
+
+  * Add Debian packaging
+
+ -- jordi fita mas <jordi@tandem.blog>  Mon, 19 Jun 2023 08:54:47 +0000

debian/control

@@ -0,0 +1,22 @@
+Source: postgresql-iban
+Section: database
+Priority: optional
+Maintainer: jordi fita mas <jordi@tandem.blog>
+Build-Depends:
+  debhelper-compat (= 13),
+  postgresql-all (>= 217~),
+Standards-Version: 4.6.0
+Vcs-Browser: https://github.com/yorickdewid/PostgreSQL-IBAN
+Vcs-Git: https://github.com/yorickdewid/PostgreSQL-IBAN.git
+Homepage: https://github.com/yorickdewid/PostgreSQL-IBAN
+Rules-Requires-Root: no
+
+Package: postgresql-15-iban
+Architecture: any
+Depends:
+  ${shlibs:Depends},
+  ${misc:Depends},
+  ${postgresql:Depends}
+description: IBAN type for PostgreSQL 
+ PostgreSQL IBAN extension that can verify International Bank Account Numbers.
+ This ensures that only valid bank account numbers are stored.

debian/control.in

@@ -0,0 +1,22 @@
+Source: postgresql-iban
+Section: database
+Priority: optional
+Maintainer: jordi fita mas <jordi@tandem.blog>
+Build-Depends:
+  debhelper-compat (= 13),
+  postgresql-all (>= 217~),
+Standards-Version: 4.6.0
+Vcs-Browser: https://github.com/yorickdewid/PostgreSQL-IBAN
+Vcs-Git: https://github.com/yorickdewid/PostgreSQL-IBAN.git
+Homepage: https://github.com/yorickdewid/PostgreSQL-IBAN
+Rules-Requires-Root: no
+
+Package: postgresql-PGVERSION-iban
+Architecture: any
+Depends:
+  ${shlibs:Depends},
+  ${misc:Depends},
+  ${postgresql:Depends}
+description: IBAN type for PostgreSQL 
+ PostgreSQL IBAN extension that can verify International Bank Account Numbers.
+ This ensures that only valid bank account numbers are stored.

debian/copyright

@@ -0,0 +1,29 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Source: https://github.com/yorickdewid/PostgreSQL-IBAN
+Upstream-Name: PostgreSQL-IBAN
+Upstream-Contact: yorick17@outlook.com
+
+Files: *
+Copyright: 2016 Yorick de Wid
+License: GPL-3+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+ .
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+Comment:
+ On Debian systems, the complete text of the GNU General Public
+ License version 3 can be found in "/usr/share/common-licenses/GPL-3".
+
+Files: debian/*
+Copyright: 2023 jordi fita mas
+License: GPL-3+
+ This debian package is distributed under the same license as the source
+ package.

debian/pgversions

@@ -0,0 +1 @@
+13+

debian/rules

@@ -0,0 +1,6 @@
+#!/usr/bin/make -f
+
+include /usr/share/postgresql-common/pgxs_debian_control.mk
+
+%:
+	dh $@ --with pgxs_loop

debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

iban.cpp

@@ -1,6 +1,7 @@
 /*
  * IBAN: PostgreSQL functions and datatype
  * Copyright © 2016 Yorick de Wid <yorick17@outlook.com>
+ * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
@@ -21,52 +22,78 @@ extern "C"
 {
 
 #include "postgres.h"
+
 #include "utils/builtins.h"
 #include "libpq/pqformat.h"
 
 }
 
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <cctype>
 #include <regex>
 
-#include "specification.h"
-#include "validate.h"
-
-// #define PG_RETURN_IBAN_P(x) PG_RETURN_POINTER(x)
-
-extern "C"
+class Specification {
+  public:
+	Specification(std::string structure, size_t length)
+		: structure{ structure }
+		, m_length{ length }
 	{
-	PG_MODULE_MAGIC;
+	};
 	
-	typedef char Iban;
+	inline size_t getLength() const noexcept
+	{
+		return m_length;
 	}
 
-void Validate::addSpecification(Specification* specPtr) {
-	this->specifications[specPtr->countryCode] = specPtr;
+	std::string structure;
+
+private:
+	size_t m_length;
+};
+
+class Validate {
+  public:
+	Validate();
+
+	bool isValid(std::string arg);
+	
+	void addSpecification(std::string countryCode, size_t length, std::string structure) noexcept
+	{
+		specifications.emplace(countryCode, std::make_unique<Specification>(structure, length));
 	}
 
+	std::map<std::string, std::unique_ptr<Specification>> specifications;
+};
+
+/* Validator global instance. */
+static Validate validator;
+
 /**
 * Calculates the MOD 97 10 of the passed IBAN as specified in ISO7064.
 *
 * @param string iban
 * @returns {bool}
 */
-bool iso7064Mod97_10(std::string iBan) {
-	std::rotate(iBan.begin(), iBan.begin() + 4, iBan.end());
-	std::string numberstring;//will contain the letter substitutions
-	for (const auto& c : iBan) {
-		if (std::isdigit(c))
+static bool iso7064Mod97_10(std::string iban) {
+	std::rotate(iban.begin(), iban.begin() + 4, iban.end());
+	
+	/* Will contain the letter substitutions */
+	std::string numberstring;
+	numberstring.reserve(iban.size());
+
+	for (const auto& c : iban) {
+		if (std::isdigit(c)) {
 			numberstring += c;
-		if (std::isupper(c))
+		}
+		if (std::isupper(c)) {
 			numberstring += std::to_string(static_cast<int>(c) - 55);
 		}
-	//implements a stepwise check for mod 97 in chunks of 9 at the first time
-	// , then in chunks of seven prepended by the last mod 97 operation converted
-	//to a string
-	int segstart = 0;
+	}
+
+	/*
+	 * Implements a stepwise check for mod 97 in chunks of 9 at the first time
+	 * then in chunks of seven prepended by the last mod 97 operation converted
+	 * to a string
+	 */
+	size_t segstart = 0;
 	int step = 9;
 	std::string prepended;
 	long number = 0;
@@ -74,17 +101,19 @@ bool iso7064Mod97_10(std::string iBan) {
 		number = std::stol(prepended + numberstring.substr(segstart, step));
 		int remainder = number % 97;
 		prepended = std::to_string(remainder);
-		if (remainder < 10)
+		if (remainder < 10) {
 			prepended = "0" + prepended;
+		}
 		segstart = segstart + step;
 		step = 7;
 	}
+
 	number = std::stol(prepended + numberstring.substr(segstart));
-	return (number % 97 == 1);
+	return number % 97 == 1;
 }
 
 /**
-* parse the bban structure used to configure each iban specification and returns a matching regular expression.
+* Parse the IBAN structure used to configure each iban specification and returns a matching regular expression.
 * a structure is composed of blocks of 3 characters (one letter and 2 digits). each block represents
 * a logical group in the typical representation of the bban. for each group, the letter indicates which characters
 * are allowed in this group and the following 2-digits number tells the length of the group.
@@ -92,14 +121,13 @@ bool iso7064Mod97_10(std::string iBan) {
 * @param {string} structure the structure to parse
 * @returns {regexp}
 */
-std::regex parseStructure(std::string structure) {
+static std::regex parseStructure(std::string structure) {
 	std::smatch match;
 
 	std::string::const_iterator text_iter = structure.cbegin();
 	std::ostringstream result;
 
-	while (std::regex_search(text_iter, structure.cend(), match,
-	                         std::regex("(.{3})"))) {
+	while (std::regex_search(text_iter, structure.cend(), match, std::regex("(.{3})"))) {
 		std::string format;
 		char pattern = match[0].str()[0];
 		int repeats = std::stoi((match[0].str().substr(1)));
@@ -124,320 +152,225 @@ std::regex parseStructure(std::string structure) {
 	return std::regex(regex.c_str());
 }
 
-bool Validate::isValid(std::string arg) {
-	Specification* spec = new Specification(arg);
-
+bool Validate::isValid(std::string account) {
 	/* Convert uppercase */
-	std::transform(spec->example.begin(), spec->example.end(),
-	               spec->example.begin(), toupper);
+	std::transform(account.begin(), account.end(), account.begin(), toupper);
+
+	/* Reject anything too small */
+	if (account.length() < 3) {
+		return false;
+	}
 
 	/* Match on country */
-	spec->countryCode = spec->example.substr(0, 2);
-	spec->length = spec->example.length();
-	Specification* specFound = this->specifications[spec->countryCode];
-	if (!specFound)
+	const std::string& countryCode = account.substr(0, 2);
+	const std::string& shortened = account.substr(4);
+
+	const std::unique_ptr<Specification>& specFound = specifications[countryCode];
+	if (!specFound) {
 		return false;
+	}
 
 	/* Test accountnumber */
-	std::string shortened = spec->example.substr(4, spec->example.length());
-	bool result = specFound->length == spec->length
-	              && specFound->countryCode.compare(spec->countryCode) == 0
+	return specFound->getLength() == account.length()
 	              && std::regex_match(shortened, parseStructure(specFound->structure))
-	              && iso7064Mod97_10(spec->example);
-
-	delete spec;
-	return result;
-}
-
-Validate::~Validate() {
-	for (auto it = specifications.begin(); it != specifications.end(); it++) {
-		delete it->second;
-	}
+	              && iso7064Mod97_10(account);
 }
 
 Validate::Validate() {
-	addSpecification(new Specification(
-	                     "AD", 24, "F04F04A12",
-	                     "AD1200012030200359100100"));
-	addSpecification(new Specification(
-	                     "AE", 23, "F03F16",
-	                     "AE070331234567890123456"));
-	addSpecification(new Specification(
-	                     "AL", 28, "F08A16",
-	                     "AL47212110090000000235698741"));
-	addSpecification(new Specification(
-	                     "AT", 20, "F05F11",
-	                     "AT611904300234573201"));
-	addSpecification(new Specification(
-	                     "AZ", 28, "U04A20",
-	                     "AZ21NABZ00000000137010001944"));
-	addSpecification(new Specification(
-	                     "BA", 20, "F03F03F08F02",
-	                     "BA391290079401028494"));
-	addSpecification(new Specification(
-	                     "BE", 16, "F03F07F02",
-	                     "BE68539007547034"));
-	addSpecification(new Specification(
-	                     "BG", 22, "U04F04F02A08",
-	                     "BG80BNBG96611020345678"));
-	addSpecification(new Specification(
-	                     "BH", 22, "U04A14",
-	                     "BH67BMAG00001299123456"));
-	addSpecification(new Specification(
-	                     "BR", 29, "F08F05F10U01A01",
-	                     "BR9700360305000010009795493P1"));
-	addSpecification(new Specification(
-	                     "CH", 21, "F05A12",
-	                     "CH9300762011623852957"));
-	addSpecification(new Specification(
-	                     "CR", 21, "F03F14",
-	                     "CR0515202001026284066"));
-	addSpecification(new Specification(
-	                     "CY", 28, "F03F05A16",
-	                     "CY17002001280000001200527600"));
-	addSpecification(new Specification(
-	                     "CZ", 24, "F04F06F10",
-	                     "CZ6508000000192000145399"));
-	addSpecification(new Specification(
-	                     "DE", 22, "F08F10",
-	                     "DE89370400440532013000"));
-	addSpecification(new Specification(
-	                     "DK", 18, "F04F09F01",
-	                     "DK5000400440116243"));
-	addSpecification(new Specification(
-	                     "DO", 28, "U04F20",
-	                     "DO28BAGR00000001212453611324"));
-	addSpecification(new Specification(
-	                     "EE", 20, "F02F02F11F01",
-	                     "EE382200221020145685"));
-	addSpecification(new Specification(
-	                     "ES", 24, "F04F04F01F01F10",
-	                     "ES9121000418450200051332"));
-	addSpecification(new Specification(
-	                     "FI", 18, "F06F07F01",
-	                     "FI2112345600000785"));
-	addSpecification(new Specification(
-	                     "FO", 18, "F04F09F01",
-	                     "FO6264600001631634"));
-	addSpecification(new Specification(
-	                     "FR", 27, "F05F05A11F02",
-	                     "FR1420041010050500013M02606"));
-	addSpecification(new Specification(
-	                     "GB", 22, "U04F06F08",
-	                     "GB29NWBK60161331926819"));
-	addSpecification(new Specification(
-	                     "GE", 22, "U02F16",
-	                     "GE29NB0000000101904917"));
-	addSpecification(new Specification(
-	                     "GI", 23, "U04A15",
-	                     "GI75NWBK000000007099453"));
-	addSpecification(new Specification(
-	                     "GL", 18, "F04F09F01",
-	                     "GL8964710001000206"));
-	addSpecification(new Specification(
-	                     "GR", 27, "F03F04A16",
-	                     "GR1601101250000000012300695"));
-	addSpecification(new Specification(
-	                     "GT", 28, "A04A20",
-	                     "GT82TRAJ01020000001210029690"));
-	addSpecification(new Specification(
-	                     "HR", 21, "F07F10",
-	                     "HR1210010051863000160"));
-	addSpecification(new Specification(
-	                     "HU", 28, "F03F04F01F15F01",
-	                     "HU42117730161111101800000000"));
-	addSpecification(new Specification(
-	                     "IE", 22, "U04F06F08",
-	                     "IE29AIBK93115212345678"));
-	addSpecification(new Specification(
-	                     "IL", 23, "F03F03F13",
-	                     "IL620108000000099999999"));
-	addSpecification(new Specification(
-	                     "IS", 26, "F04F02F06F10",
-	                     "IS140159260076545510730339"));
-	addSpecification(new Specification(
-	                     "IT", 27, "U01F05F05A12",
-	                     "IT60X0542811101000000123456"));
-	addSpecification(new Specification(
-	                     "KW", 30, "U04A22",
-	                     "KW81CBKU0000000000001234560101"));
-	addSpecification(new Specification(
-	                     "KZ", 20, "F03A13",
-	                     "KZ86125KZT5004100100"));
-	addSpecification(new Specification(
-	                     "LB", 28, "F04A20",
-	                     "LB62099900000001001901229114"));
-	addSpecification(new Specification(
-	                     "LC", 32, "U04F24",
-	                     "LC07HEMM000100010012001200013015"));
-	addSpecification(new Specification(
-	                     "LI", 21, "F05A12",
-	                     "LI21088100002324013AA"));
-	addSpecification(new Specification(
-	                     "LT", 20, "F05F11",
-	                     "LT121000011101001000"));
-	addSpecification(new Specification(
-	                     "LU", 20, "F03A13",
-	                     "LU280019400644750000"));
-	addSpecification(new Specification(
-	                     "LV", 21, "U04A13",
-	                     "LV80BANK0000435195001"));
-	addSpecification(new Specification(
-	                     "MC", 27, "F05F05A11F02",
-	                     "MC5811222000010123456789030"));
-	addSpecification(new Specification(
-	                     "MD", 24, "U02A18",
-	                     "MD24AG000225100013104168"));
-	addSpecification(new Specification(
-	                     "ME", 22, "F03F13F02",
-	                     "ME25505000012345678951"));
-	addSpecification(new Specification(
-	                     "MK", 19, "F03A10F02",
-	                     "MK07250120000058984"));
-	addSpecification(new Specification(
-	                     "MR", 27, "F05F05F11F02",
-	                     "MR1300020001010000123456753"));
-	addSpecification(new Specification(
-	                     "MT", 31, "U04F05A18",
-	                     "MT84MALT011000012345MTLCAST001S"));
-	addSpecification(new Specification(
-	                     "MU", 30, "U04F02F02F12F03U03",
-	                     "MU17BOMM0101101030300200000MUR"));
-	addSpecification(new Specification(
-	                     "NL", 18, "U04F10",
-	                     "NL91ABNA0417164300"));
-	addSpecification(new Specification(
-	                     "NO", 15, "F04F06F01",
-	                     "NO9386011117947"));
-	addSpecification(new Specification(
-	                     "PK", 24, "U04A16",
-	                     "PK36SCBL0000001123456702"));
-	addSpecification(new Specification(
-	                     "PL", 28, "F08F16",
-	                     "PL61109010140000071219812874"));
-	addSpecification(new Specification(
-	                     "PS", 29, "U04A21",
-	                     "PS92PALS000000000400123456702"));
-	addSpecification(new Specification(
-	                     "PT", 25, "F04F04F11F02",
-	                     "PT50000201231234567890154"));
-	addSpecification(new Specification(
-	                     "RO", 24, "U04A16",
-	                     "RO49AAAA1B31007593840000"));
-	addSpecification(new Specification(
-	                     "RS", 22, "F03F13F02",
-	                     "RS35260005601001611379"));
-	addSpecification(new Specification(
-	                     "SA", 24, "F02A18",
-	                     "SA0380000000608010167519"));
-	addSpecification(new Specification(
-	                     "SE", 24, "F03F16F01",
-	                     "SE4550000000058398257466"));
-	addSpecification(new Specification(
-	                     "SI", 19, "F05F08F02",
-	                     "SI56263300012039086"));
-	addSpecification(new Specification(
-	                     "SK", 24, "F04F06F10",
-	                     "SK3112000000198742637541"));
-	addSpecification(new Specification(
-	                     "SM", 27, "U01F05F05A12",
-	                     "SM86U0322509800000000270100"));
-	addSpecification(new Specification(
-	                     "ST", 25, "F08F11F02",
-	                     "ST68000100010051845310112"));
-	addSpecification(new Specification(
-	                     "TL", 23, "F03F14F02",
-	                     "TL380080012345678910157"));
-	addSpecification(new Specification(
-	                     "TN", 24, "F02F03F13F02",
-	                     "TN5910006035183598478831"));
-	addSpecification(new Specification(
-	                     "TR", 26, "F05F01A16",
-	                     "TR330006100519786457841326"));
-	addSpecification(new Specification(
-	                     "VG", 24, "U04F16",
-	                     "VG96VPVG0000012345678901"));
-	addSpecification(new Specification(
-	                     "XK", 20, "F04F10F02",
-	                     "XK051212012345678906"));
-	addSpecification(new Specification(
-	                     "AO", 25, "F21",
-	                     "AO69123456789012345678901"));
-	addSpecification(new Specification(
-	                     "BF", 27, "F23",
-	                     "BF2312345678901234567890123"));
-	addSpecification(new Specification(
-	                     "BI", 16, "F12",
-	                     "BI41123456789012"));
-	addSpecification(new Specification(
-	                     "BJ", 28, "F24",
-	                     "BJ39123456789012345678901234"));
-	addSpecification(new Specification(
-	                     "CI", 28, "U01F23",
-	                     "CI17A12345678901234567890123"));
-	addSpecification(new Specification(
-	                     "CM", 27, "F23",
-	                     "CM9012345678901234567890123"));
-	addSpecification(new Specification(
-	                     "CV", 25, "F21",
-	                     "CV30123456789012345678901"));
-	addSpecification(new Specification(
-	                     "DZ", 24, "F20",
-	                     "DZ8612345678901234567890"));
-	addSpecification(new Specification(
-	                     "IR", 26, "F22",
-	                     "IR861234568790123456789012"));
-	addSpecification(new Specification(
-	                     "JO", 30, "A04F22",
-	                     "JO15AAAA1234567890123456789012"));
-	addSpecification(new Specification(
-	                     "MG", 27, "F23",
-	                     "MG1812345678901234567890123"));
-	addSpecification(new Specification(
-	                     "ML", 28, "U01F23",
-	                     "ML15A12345678901234567890123"));
-	addSpecification(new Specification(
-	                     "MZ", 25, "F21",
-	                     "MZ25123456789012345678901"));
-	addSpecification(new Specification(
-	                     "QA", 29, "U04A21",
-	                     "QA30AAAA123456789012345678901"));
-	addSpecification(new Specification(
-	                     "SN", 28, "U01F23",
-	                     "SN52A12345678901234567890123"));
-	addSpecification(new Specification(
-	                     "UA", 29, "F25",
-	                     "UA511234567890123456789012345"));
-	addSpecification(new Specification(
-	                     "EG", 27, "F23",
-	                     "EG1100006001880800100014553"));
-	addSpecification(new Specification(
-	                     "CG", 27, "F23",
-	                     "CG5230011000202151234567890"));
-	addSpecification(new Specification(
-	                     "GA", 27, "F23",
-	                     "GA2140002000055602673300064"));
-
+	addSpecification(
+	                     "AD", 24, "F04F04A12");
+	addSpecification(
+	                     "AE", 23, "F03F16");
+	addSpecification(
+	                     "AL", 28, "F08A16");
+	addSpecification(
+	                     "AT", 20, "F05F11");
+	addSpecification(
+	                     "AZ", 28, "U04A20");
+	addSpecification(
+	                     "BA", 20, "F03F03F08F02");
+	addSpecification(
+	                     "BE", 16, "F03F07F02");
+	addSpecification(
+	                     "BG", 22, "U04F04F02A08");
+	addSpecification(
+	                     "BH", 22, "U04A14");
+	addSpecification(
+	                     "BR", 29, "F08F05F10U01A01");
+	addSpecification(
+	                     "CH", 21, "F05A12");
+	addSpecification(
+	                     "CR", 21, "F03F14");
+	addSpecification(
+	                     "CY", 28, "F03F05A16");
+	addSpecification(
+	                     "CZ", 24, "F04F06F10");
+	addSpecification(
+	                     "DE", 22, "F08F10");
+	addSpecification(
+	                     "DK", 18, "F04F09F01");
+	addSpecification(
+	                     "DO", 28, "U04F20");
+	addSpecification(
+	                     "EE", 20, "F02F02F11F01");
+	addSpecification(
+	                     "ES", 24, "F04F04F01F01F10");
+	addSpecification(
+	                     "FI", 18, "F06F07F01");
+	addSpecification(
+	                     "FO", 18, "F04F09F01");
+	addSpecification(
+	                     "FR", 27, "F05F05A11F02");
+	addSpecification(
+	                     "GB", 22, "U04F06F08");
+	addSpecification(
+	                     "GE", 22, "U02F16");
+	addSpecification(
+	                     "GI", 23, "U04A15");
+	addSpecification(
+	                     "GL", 18, "F04F09F01");
+	addSpecification(
+	                     "GR", 27, "F03F04A16");
+	addSpecification(
+	                     "GT", 28, "A04A20");
+	addSpecification(
+	                     "HR", 21, "F07F10");
+	addSpecification(
+	                     "HU", 28, "F03F04F01F15F01");
+	addSpecification(
+	                     "IE", 22, "U04F06F08");
+	addSpecification(
+	                     "IL", 23, "F03F03F13");
+	addSpecification(
+	                     "IS", 26, "F04F02F06F10");
+	addSpecification(
+	                     "IT", 27, "U01F05F05A12");
+	addSpecification(
+	                     "KW", 30, "U04A22");
+	addSpecification(
+	                     "KZ", 20, "F03A13");
+	addSpecification(
+	                     "LB", 28, "F04A20");
+	addSpecification(
+	                     "LC", 32, "U04F24");
+	addSpecification(
+	                     "LI", 21, "F05A12");
+	addSpecification(
+	                     "LT", 20, "F05F11");
+	addSpecification(
+	                     "LU", 20, "F03A13");
+	addSpecification(
+	                     "LV", 21, "U04A13");
+	addSpecification(
+	                     "MC", 27, "F05F05A11F02");
+	addSpecification(
+	                     "MD", 24, "U02A18");
+	addSpecification(
+	                     "ME", 22, "F03F13F02");
+	addSpecification(
+	                     "MK", 19, "F03A10F02");
+	addSpecification(
+	                     "MR", 27, "F05F05F11F02");
+	addSpecification(
+	                     "MT", 31, "U04F05A18");
+	addSpecification(
+	                     "MU", 30, "U04F02F02F12F03U03");
+	addSpecification(
+	                     "NL", 18, "U04F10");
+	addSpecification(
+	                     "NO", 15, "F04F06F01");
+	addSpecification(
+	                     "PK", 24, "U04A16");
+	addSpecification(
+	                     "PL", 28, "F08F16");
+	addSpecification(
+	                     "PS", 29, "U04A21");
+	addSpecification(
+	                     "PT", 25, "F04F04F11F02");
+	addSpecification(
+	                     "RO", 24, "U04A16");
+	addSpecification(
+	                     "RS", 22, "F03F13F02");
+	addSpecification(
+	                     "SA", 24, "F02A18");
+	addSpecification(
+	                     "SE", 24, "F03F16F01");
+	addSpecification(
+	                     "SI", 19, "F05F08F02");
+	addSpecification(
+	                     "SK", 24, "F04F06F10");
+	addSpecification(
+	                     "SM", 27, "U01F05F05A12");
+	addSpecification(
+	                     "ST", 25, "F08F11F02");
+	addSpecification(
+	                     "TL", 23, "F03F14F02");
+	addSpecification(
+	                     "TN", 24, "F02F03F13F02");
+	addSpecification(
+	                     "TR", 26, "F05F01A16");
+	addSpecification(
+	                     "VG", 24, "U04F16");
+	addSpecification(
+	                     "XK", 20, "F04F10F02");
+	addSpecification(
+	                     "AO", 25, "F21");
+	addSpecification(
+	                     "BF", 27, "F23");
+	addSpecification(
+	                     "BI", 16, "F12");
+	addSpecification(
+	                     "BJ", 28, "F24");
+	addSpecification(
+	                     "CI", 28, "U01F23");
+	addSpecification(
+	                     "CM", 27, "F23");
+	addSpecification(
+	                     "CV", 25, "F21");
+	addSpecification(
+	                     "DZ", 24, "F20");
+	addSpecification(
+	                     "IR", 26, "F22");
+	addSpecification(
+	                     "JO", 30, "A04F22");
+	addSpecification(
+	                     "MG", 27, "F23");
+	addSpecification(
+	                     "ML", 28, "U01F23");
+	addSpecification(
+	                     "MZ", 25, "F21");
+	addSpecification(
+	                     "QA", 29, "U04A21");
+	addSpecification(
+	                     "SN", 28, "U01F23");
+	addSpecification(
+	                     "UA", 29, "F25");
+	addSpecification(
+	                     "EG", 27, "F23");
+	addSpecification(
+	                     "CG", 27, "F23");
+	addSpecification(
+	                     "GA", 27, "F23");
 }
 
 /**
 * Separate CXX and C logic to minimize unexpected or malformed symbols due to
-* language conversions. Also catch all exceptions the std++ can throw since
+* language conversions. Also demark all exceptions the std++ can throw since
 * PostgreSQL is not able to handle them.
 *
 * @param {string} iban
 * @returns {bool}
 */
 namespace {
+
 bool account_validate_text(text *iban) {
 	char *ciban;
 	bool result;
-	Validate val;
 
 	ciban = text_to_cstring(iban);
 
 	try {
-		result = val.isValid(std::string(ciban));
+		result = validator.isValid(ciban);
 	} catch (std::exception& e) {
 		elog(ERROR, "%s", e.what());
 		return false;
@@ -448,10 +381,9 @@ bool account_validate_text(text *iban) {
 
 bool account_validate_str(char *iban) {
 	bool result;
-	Validate val;
 
 	try {
-		result = val.isValid(std::string(iban));
+		result = validator.isValid(iban);
 	} catch (std::exception& e) {
 		elog(ERROR, "%s", e.what());
 		return false;
@@ -459,10 +391,16 @@ bool account_validate_str(char *iban) {
 
 	return result;
 }
-}
+
+} // namespace
 
 extern "C"
 {
+
+PG_MODULE_MAGIC;
+
+typedef char Iban;
+
 /**************************************************************************
  * Input/Output functions
  **************************************************************************/
@@ -537,4 +475,5 @@ extern "C"
 
 	PG_RETURN_BOOL(result);
 }
-}
+
+} // extern "C"

specification.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <string>
-
-class Specification {
-  public:
-	Specification(std::string countryCode, int length, std::string structure, std::string example) :
-		countryCode(countryCode),
-		length(length),
-		structure(structure),
-		example(example) {
-	};
-	Specification(std::string example) : example(example) {};
-	std::string countryCode;
-	int length;
-	std::string structure;
-	std::string example;
-};

validate.h

@@ -1,14 +0,0 @@
-#pragma once
-#include <memory>
-#include <map>
-#include "specification.h"
-
-class Validate {
-  public:
-	Validate();
-	~Validate();
-	bool isValid(std::string arg);
-	void addSpecification(Specification* specPtr);
-
-	std::map<std::string, Specification*> specifications;
-};