1 files changed, 0 insertions, 193 deletions
diff --git a/generator/field.cpp b/generator/field.cpp
deleted file mode 100644
index 7e7453d..0000000
--- a/generator/field.cpp
+++ /dev/null

@@ -1,193 +0,0 @@
-#include "field.h"
-#include <stdexcept>
-#include <utility>
-namespace cadence {
-  namespace generator {
-    field::field(const field& other)
-    {
-      type_ = other.type_;
-      name_ = other.name_;
-      switch (type_)
-      {
-        case type::integer:
-        {
-          integer_ = other.integer_;
-          break;
-        }
-        case type::string:
-        {
-          new(&string_) std::string(other.string_);
-          break;
-        }
-        case type::invalid:
-        {
-          break;
-        }
-      }
-    }
-    field::field(field&& other) : field()
-    {
-      swap(*this, other);
-    }
-    field& field::operator=(field other)
-    {
-      swap(*this, other);
-      return *this;
-    }
-    void swap(field& first, field& second)
-    {
-      using type = field::type;
-      type tempType = first.type_;
-      std::string tempName = std::move(first.name_);
-      int tempInteger;
-      std::string tempString;
-      switch (first.type_)
-      {
-        case type::integer:
-        {
-          tempInteger = first.integer_;
-          break;
-        }
-        case type::string:
-        {
-          tempString = std::move(tempString);
-          break;
-        }
-        case type::invalid:
-        {
-          break;
-        }
-      }
-      first.~field();
-      first.type_ = second.type_;
-      first.name_ = std::move(second.name_);
-      switch (second.type_)
-      {
-        case type::integer:
-        {
-          first.integer_ = second.integer_;
-          break;
-        }
-        case type::string:
-        {
-          new(&first.string_) std::string(std::move(second.string_));
-          break;
-        }
-        case type::invalid:
-        {
-          break;
-        }
-      }
-      second.~field();
-      second.type_ = tempType;
-      second.name_ = std::move(tempName);
-      switch (tempType)
-      {
-        case type::integer:
-        {
-          second.integer_ = tempInteger;
-          break;
-        }
-        case type::string:
-        {
-          new(&second.string_) std::string(std::move(tempString));
-          break;
-        }
-        case type::invalid:
-        {
-          break;
-        }
-      }
-    }
-    field::~field()
-    {
-      switch (type_)
-      {
-        case type::string:
-        {
-          using string_type = std::string;
-          string_.~string_type();
-          break;
-        }
-        case type::integer:
-        case type::invalid:
-        {
-          break;
-        }
-      }
-    }
-    field::field(
-      std::string name,
-      int arg) :
-        type_(type::integer),
-        name_(name),
-        integer_(arg)
-    {
-    }
-    int field::getInteger() const
-    {
-      if (type_ != type::integer)
-      {
-        throw std::domain_error("field::getInteger called on non-integer field");
-      }
-      return integer_;
-    }
-    field::field(
-      std::string name,
-      std::string arg) :
-        type_(type::string),
-        name_(name)
-    {
-      new(&string_) std::string(arg);
-    }
-    std::string field::getString() const
-    {
-      if (type_ != type::string)
-      {
-        throw std::domain_error("field::getString called on non-string field");
-      }
-      return string_;
-    }
-  };
-};

diff --git a/generator/field.cpp b/generator/field.cpp deleted file mode 100644 index 7e7453d..0000000 --- a/generator/field.cpp +++ /dev/null
@@ -1,193 +0,0 @@
1	#include "field.h"
2	#include <stdexcept>
3	#include <utility>
4
5	namespace cadence {
6	namespace generator {
7
8	field::field(const field& other)
9	{
10	type_ = other.type_;
11	name_ = other.name_;
12
13	switch (type_)
14	{
15	case type::integer:
16	{
17	integer_ = other.integer_;
18
19	break;
20	}
21
22	case type::string:
23	{
24	new(&string_) std::string(other.string_);
25
26	break;
27	}
28
29	case type::invalid:
30	{
31	break;
32	}
33	}
34	}
35
36	field::field(field&& other) : field()
37	{
38	swap(*this, other);
39	}
40
41	field& field::operator=(field other)
42	{
43	swap(*this, other);
44
45	return *this;
46	}
47
48	void swap(field& first, field& second)
49	{
50	using type = field::type;
51
52	type tempType = first.type_;
53	std::string tempName = std::move(first.name_);
54	int tempInteger;
55	std::string tempString;
56
57	switch (first.type_)
58	{
59	case type::integer:
60	{
61	tempInteger = first.integer_;
62
63	break;
64	}
65
66	case type::string:
67	{
68	tempString = std::move(tempString);
69
70	break;
71	}
72
73	case type::invalid:
74	{
75	break;
76	}
77	}
78
79	first.~field();
80
81	first.type_ = second.type_;
82	first.name_ = std::move(second.name_);
83
84	switch (second.type_)
85	{
86	case type::integer:
87	{
88	first.integer_ = second.integer_;
89
90	break;
91	}
92
93	case type::string:
94	{
95	new(&first.string_) std::string(std::move(second.string_));
96
97	break;
98	}
99
100	case type::invalid:
101	{
102	break;
103	}
104	}
105
106	second.~field();
107
108	second.type_ = tempType;
109	second.name_ = std::move(tempName);
110
111	switch (tempType)
112	{
113	case type::integer:
114	{
115	second.integer_ = tempInteger;
116
117	break;
118	}
119
120	case type::string:
121	{
122	new(&second.string_) std::string(std::move(tempString));
123
124	break;
125	}
126
127	case type::invalid:
128	{
129	break;
130	}
131	}
132	}
133
134	field::~field()
135	{
136	switch (type_)
137	{
138	case type::string:
139	{
140	using string_type = std::string;
141	string_.~string_type();
142
143	break;
144	}
145
146	case type::integer:
147	case type::invalid:
148	{
149	break;
150	}
151	}
152	}
153
154	field::field(
155	std::string name,
156	int arg) :
157	type_(type::integer),
158	name_(name),
159	integer_(arg)
160	{
161	}
162
163	int field::getInteger() const
164	{
165	if (type_ != type::integer)
166	{
167	throw std::domain_error("field::getInteger called on non-integer field");
168	}
169
170	return integer_;
171	}
172
173	field::field(
174	std::string name,
175	std::string arg) :
176	type_(type::string),
177	name_(name)
178	{
179	new(&string_) std::string(arg);
180	}
181
182	std::string field::getString() const
183	{
184	if (type_ != type::string)
185	{
186	throw std::domain_error("field::getString called on non-string field");
187	}
188
189	return string_;
190	}
191
192	};
193	};