diff --git a/include/private-include/zipr_constants.h b/include/private-include/constants.h
similarity index 100%
rename from include/private-include/zipr_constants.h
rename to include/private-include/constants.h
diff --git a/include/private-include/dollop.h b/include/private-include/dollop.h
index f6bbef6623cab1a454ae021e6098242a6cc36117..7f6ee5ef99712620b4d614cff1fc07174512cfa7 100644
--- a/include/private-include/dollop.h
+++ b/include/private-include/dollop.h
@@ -19,6 +19,7 @@ namespace Zipr_SDK
Placeable_t() {}
Placeable_t(const Placeable_t& copy) = delete;
public:
+ virtual ~Placeable_t() {}
virtual void Place(RangeAddress_t place) = 0;
virtual RangeAddress_t getPlace() const = 0;
virtual bool isPlaced() const = 0;
@@ -33,6 +34,7 @@ namespace Zipr_SDK
DollopPatch_t() { }
DollopPatch_t(const DollopPatch_t& copy) = delete;
public:
+ virtual ~DollopPatch_t() { }
virtual Dollop_t* getTarget() const = 0 ;
virtual void setTarget(Dollop_t *target) = 0 ;
@@ -46,6 +48,8 @@ namespace Zipr_SDK
DollopEntry_t() { }
DollopEntry_t(const DollopEntry_t& copy) = delete;
public:
+ virtual ~DollopEntry_t() { }
+
virtual void setTargetDollop(Dollop_t *target) = 0 ;
virtual void MemberOfDollop(Dollop_t *member_of) = 0 ;
@@ -67,6 +71,7 @@ namespace Zipr_SDK
Dollop_t(const Dollop_t& copy) = delete;
public:
+ virtual ~Dollop_t() {}
virtual size_t getSize() const = 0;
virtual size_t getDollopEntryCount() const = 0;
diff --git a/include/private-include/dollop_man.h b/include/private-include/dollop_man.h
index a15c6d73dd701f69ea0f59d536c01e4af5c89fed..6d2ecf96de0cd5e892e201e4a1e52686507bbb6f 100644
--- a/include/private-include/dollop_man.h
+++ b/include/private-include/dollop_man.h
@@ -17,9 +17,12 @@ namespace Zipr_SDK
class DollopManager_t
{
- public:
+ protected:
DollopManager_t() {};
+ DollopManager_t(const DollopManager_t& copy) = delete;
+ public:
+ virtual ~DollopManager_t() {};
/*
* Add a dollop and all its fallthrough dollops
diff --git a/include/private-include/memory_space.h b/include/private-include/memory_space.h
index 2cba832c8b15c3ef3ba5f15b01080cb536e91bf0..481d0310defc574cf9280f7ff8c066d9ce490ad4 100644
--- a/include/private-include/memory_space.h
+++ b/include/private-include/memory_space.h
@@ -7,9 +7,14 @@ namespace Zipr_SDK
using RangeSetBounds_t = pair<RangeSet_t::const_iterator,RangeSet_t::const_iterator>;
// a memory space _is_ a map of range addres to char, with additional functionality.
- class MemorySpace_t : public map<RangeAddress_t,char>
+ class MemorySpace_t : virtual public map<RangeAddress_t,char>
{
+ protected:
+ MemorySpace_t(){}
+ MemorySpace_t(const MemorySpace_t& copy) = delete;
+
public:
+ virtual ~MemorySpace_t(){}
// range operatations
virtual void splitFreeRange(RangeAddress_t addr) = 0;
diff --git a/include/private-include/options.h b/include/private-include/options.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ccbf3aebb0aa0c4faee197ea6ac90971fafe981
--- /dev/null
+++ b/include/private-include/options.h
@@ -0,0 +1,119 @@
+
+#include <string>
+#include <unistd.h>
+#include <iostream>
+#include <sstream>
+#include <set>
+
+namespace Zipr_SDK
+{
+ using namespace std;
+
+ class ZiprOption_t
+ {
+ protected:
+ ZiprOption_t() { }
+ ZiprOption_t(const ZiprOption_t& copy) = delete;
+ public:
+ virtual ~ZiprOption_t() { }
+
+ virtual string getValueString() const = 0;
+ virtual string getNamespace() const = 0;
+ virtual string getKey() const = 0;
+ virtual string getDescription() const = 0;
+ virtual bool areRequirementMet() const = 0;
+
+ virtual void setRequired(bool req=true) = 0;
+
+ };
+
+ template <class T>
+ class ZiprTypedOption_t : virtual public ZiprOption_t
+ {
+ protected:
+ ZiprTypedOption_t() { }
+ ZiprTypedOption_t(const ZiprTypedOption_t& copy) = delete;
+ public:
+ virtual ~ZiprTypedOption_t() { }
+
+ virtual T getValue() const = 0;
+ virtual operator T() const = 0;
+
+ };
+
+
+ class ZiprStringOption_t : virtual public ZiprTypedOption_t<string>
+ {
+ protected:
+ ZiprStringOption_t() { }
+ ZiprStringOption_t(const ZiprStringOption_t& copy) = delete;
+ public:
+ virtual ~ZiprStringOption_t() { }
+ virtual void setValue(const string& ) = 0;
+
+ };
+
+ class ZiprBooleanOption_t : virtual public ZiprTypedOption_t<bool>
+ {
+ protected:
+ ZiprBooleanOption_t() { }
+ ZiprBooleanOption_t(const ZiprBooleanOption_t& copy) = delete;
+ public:
+ virtual ~ZiprBooleanOption_t() { }
+ virtual void setValue(const bool& ) = 0;
+
+ };
+
+ class ZiprIntegerOption_t : virtual public ZiprTypedOption_t<size_t>
+ {
+ protected:
+ ZiprIntegerOption_t() { }
+ ZiprIntegerOption_t(const ZiprIntegerOption_t& copy) = delete;
+ public:
+ virtual ~ZiprIntegerOption_t() { }
+ virtual void setValue(const size_t& ) = 0;
+
+ };
+
+
+ class ZiprDoubleOption_t : public ZiprTypedOption_t<double>
+ {
+ protected:
+ ZiprDoubleOption_t() { }
+ ZiprDoubleOption_t(const ZiprDoubleOption_t& copy) = delete;
+ public:
+ virtual ~ZiprDoubleOption_t() { }
+ virtual void setValue(const double& ) = 0;
+
+ };
+
+ class ZiprOptionsNamespace_t
+ {
+ protected:
+ ZiprOptionsNamespace_t() { }
+ ZiprOptionsNamespace_t(const ZiprOptionsNamespace_t& copy) = delete;
+ public:
+ virtual ~ZiprOptionsNamespace_t() { }
+ virtual string getNamespaceString() const = 0 ;
+ virtual ZiprStringOption_t* getStringOption (const string& name, const string &description="", const string& default_value="") = 0;
+ virtual ZiprIntegerOption_t* getIntegerOption(const string& name, const string &description="", const size_t& default_value=0) = 0;
+ virtual ZiprBooleanOption_t* getBooleanOption(const string& name, const string &description="", const bool & default_value=false) = 0;
+ virtual ZiprDoubleOption_t* getDoubleOption (const string& name, const string &description="", const double& default_value=0.0) = 0;
+ };
+
+ class ZiprOptionsManager_t
+ {
+ protected:
+ ZiprOptionsManager_t() { }
+ ZiprOptionsManager_t(const ZiprOptionsManager_t& copy) = delete;
+
+ public:
+ virtual ~ZiprOptionsManager_t() { }
+
+ virtual bool areRequirementsMet() const = 0;
+ virtual ZiprOptionsNamespace_t* getNamespace(const string& name) = 0;
+
+
+ };
+
+}
diff --git a/include/private-include/zipr_plugin.h b/include/private-include/plugin.h
similarity index 96%
rename from include/private-include/zipr_plugin.h
rename to include/private-include/plugin.h
index 77e5db03bcac1cbf5c6c64cd0eb7d3d7f4561a7c..f7bf1434b5d2833a9375a44e299b752b782fbcad 100644
--- a/include/private-include/zipr_plugin.h
+++ b/include/private-include/plugin.h
@@ -85,9 +85,6 @@ namespace Zipr_SDK
virtual string toString()
{ return "NamelessPlugin"; }
- virtual ZiprOptionsNamespace_t *registerOptions(ZiprOptionsNamespace_t *)
- { return new ZiprOptionsNamespace_t(""); }
-
virtual ZiprPreference_t retargetPin(const RangeAddress_t &, const Dollop_t *, RangeAddress_t &)
{ return None; }
diff --git a/include/private-include/range.h b/include/private-include/range.h
index 95d8712b4fece838b673dcb13ea4f6849ab381ee..6c0e6a7bff3a0f83e9af8e699b4d993fdf45c9d9 100644
--- a/include/private-include/range.h
+++ b/include/private-include/range.h
@@ -10,6 +10,7 @@ namespace Zipr_SDK
public:
Range_t(RangeAddress_t p_s, RangeAddress_t p_e) : m_start(p_s), m_end(p_e) { }
Range_t() : m_start(0), m_end(0) { }
+ virtual ~Range_t() {}
virtual RangeAddress_t getStart() const { return m_start; }
virtual RangeAddress_t getEnd() const { return m_end; }
diff --git a/include/private-include/zipr.h b/include/private-include/zipr.h
index 95fc13c1c5addb6fb52de4144357c512d4254149..38608e83db5dd283e382186bf403be106bc959ea 100644
--- a/include/private-include/zipr.h
+++ b/include/private-include/zipr.h
@@ -9,12 +9,16 @@ namespace Zipr_SDK
using PlacementQueue_t = set< pair<Dollop_t*,RangeAddress_t> > ;
+ class ZiprOptionsManager_t;
+
class Zipr_t
{
protected:
Zipr_t() { }
Zipr_t(const Zipr_t& copy) = delete;
+
public:
+ virtual ~Zipr_t() { }
/*
* These are public functions that the SDK user way want to use.
*/
@@ -44,6 +48,7 @@ namespace Zipr_SDK
virtual InstructionLocationMap_t* getLocationMap() = 0;
virtual DollopManager_t* getDollopManager() = 0;
virtual PlacementQueue_t* getPlacementQueue() = 0;
+ virtual ZiprOptionsManager_t* getOptionsManager() = 0;
};
diff --git a/include/private-include/zipr_options.h b/include/private-include/zipr_options.h
deleted file mode 100644
index 8bb2833fd8ee6638aaf7e2b06912c4ad8fb3b76d..0000000000000000000000000000000000000000
--- a/include/private-include/zipr_options.h
+++ /dev/null
@@ -1,368 +0,0 @@
-
-#include <string>
-#include <unistd.h>
-#include <iostream>
-#include <sstream>
-#include <set>
-
-namespace Zipr_SDK
-{
- using namespace std;
-
- using ZiprOptionType_t = enum ZiprOptionType
- {
- zotZiprUntypedOptionType,
- zotZiprIntegerOptionType,
- zotZiprDoubleOptionType,
- zotZiprBooleanOptionType,
- zotZiprStringOptionType,
- };
-
- class ZiprOption_t
- {
- public:
- ZiprOption_t(ZiprOptionType_t type, const string& key, const string& value)
- : m_key(key),
- m_untyped_value(value),
- m_observee(nullptr),
- m_takes_value(true),
- m_needs_value(true),
- m_required(false),
- m_set(false),
- m_option_type(type) {};
-
- virtual void setValue(const string &value) = 0;
- virtual void setOption() = 0;
-
- string getStringValue()
- {
- return m_untyped_value;
- }
- string getNamespace()
- {
- return m_namespace;
- }
- string getKey()
- {
- return m_key;
- }
- void setNeedsValue(bool needs_value)
- {
- m_needs_value = needs_value;
- }
- bool getNeedsValue()
- {
- return m_needs_value;
- }
- void setTakesValue(bool takes_value)
- {
- m_takes_value = takes_value;
- }
- bool getTakesValue()
- {
- return m_takes_value;
- }
-
- bool isRequired()
- {
- return m_required;
- }
- void setRequired(bool required)
- {
- m_required = required;
- }
- bool areRequirementMet()
- {
- return (!m_required) || (m_set);
- }
-
- virtual string getDescription()
- {
- return m_description;
- }
-
-
- void setDescription(string description)
- {
- m_description = description;
- }
-
- void addObserver(ZiprOption_t *observer)
- {
- assert(observer->m_option_type == m_option_type);
- //observer->setValue(m_untyped_value);
- observer->m_observee = this;
- m_observers.insert(observer);
- }
- protected:
- string m_namespace, m_key, m_untyped_value, m_description;
- set<ZiprOption_t*> m_observers;
- ZiprOption_t *m_observee;
- bool m_takes_value, m_needs_value;
- bool m_required;
- bool m_set;
- void SetObserverValues(string value)
- {
- set<ZiprOption_t*>::const_iterator it = m_observers.begin();
- set<ZiprOption_t*>::const_iterator it_end = m_observers.end();
- for (; it!=it_end; it++)
- (*it)->setValue(value);
- }
- ZiprOptionType_t m_option_type;
- };
-
- template <typename T>
- class ZiprTypedOption_t : public ZiprOption_t
- {
- public:
- ZiprTypedOption_t(ZiprOptionType_t type,
- const string& key,
- const string& value)
- : ZiprOption_t(type, key, value) {}
-
- void setValue(const string &value)
- {
- m_set = true;
- m_untyped_value = value;
- m_value = convertToTyped(value);
- }
- virtual void setOption()
- {
- }
-
- T getValue() const
- {
- if (m_observee!=nullptr)
-
- {
- ZiprTypedOption_t<T> *typed_observee =
- static_cast<ZiprTypedOption_t<T>*>(m_observee);
- return typed_observee->getValue();
- }
- return m_value;
- }
- operator T() const
- {
- return getValue();
- };
- virtual string getDescription()
- {
- return string(m_key + ": "
- + ((!m_needs_value)?"[":"")
- + "<" + getTypeName() + ">"
- + ((!m_needs_value)?"]":"")
- + ((m_description.length())?":\t":"") + m_description
- );
- }
- protected:
- T m_value;
- virtual T convertToTyped(const string& ) = 0;
- virtual string convertToUntyped(const T&) = 0;
- virtual string getTypeName() = 0;
- };
-
- template <class T>
- class ZiprCompositeOption_t : public ZiprTypedOption_t<T>, public T
- {
- public:
- ZiprCompositeOption_t(ZiprOptionType_t type,
- string key,
- string value)
- : ZiprTypedOption_t<T>(type, key, value) {}
- using ZiprTypedOption_t<T>::convertToTyped;
- void setValue(const string &value)
- {
- ZiprTypedOption_t<T>::setValue(value);
- T::operator=(convertToTyped(value));
- }
- };
-
- class ZiprStringOption_t : public ZiprCompositeOption_t<string>
- {
- public:
- ZiprStringOption_t(string key, string value = "")
- : ZiprCompositeOption_t(zotZiprStringOptionType, key, value)
- {
- setValue(value);
- }
- protected:
- string convertToTyped(const string& value_to_convert)
- {
- return string(value_to_convert);
- }
- string convertToUntyped(const string& value_to_convert)
- {
- return string(value_to_convert);
- }
- string getTypeName()
- {
- return "string";
- }
- };
-
- class ZiprBooleanOption_t : public ZiprTypedOption_t<bool>
- {
- public:
- ZiprBooleanOption_t(const string& key, const string& value = "")
- : ZiprTypedOption_t(zotZiprBooleanOptionType, key, value)
- {
- m_untyped_value = value;
- m_needs_value = false;
- }
- ZiprBooleanOption_t(const string& key, bool value)
- : ZiprTypedOption_t(zotZiprBooleanOptionType, key, "")
- {
- m_value = value;
- m_needs_value = false;
- m_untyped_value = convertToUntyped(value);
- }
- void setOption()
- {
- m_untyped_value = "true";
- m_value = true;
- m_set = true;
- }
-
- private:
- bool convertToTyped(const string& value_to_convert)
- {
- if (value_to_convert == "true")
- return true;
- else
- return false;
- }
- string convertToUntyped(const bool& value_to_convert)
- {
- return (value_to_convert ? string("true") : string("false"));
- }
- string getTypeName()
- {
- return "bool";
- }
- };
-
- class ZiprIntegerOption_t : public ZiprTypedOption_t<int>
- {
- public:
- ZiprIntegerOption_t(const string& key, const string& value = "")
- : ZiprTypedOption_t(zotZiprIntegerOptionType, key, value)
- {
- m_value = convertToTyped(value);
- }
- ZiprIntegerOption_t(const string& key, int value)
- : ZiprTypedOption_t(zotZiprIntegerOptionType, key, "")
- {
- m_value = value;
- m_untyped_value = convertToUntyped(value);
- }
- void setValue(int value)
- {
- m_value = value;
- m_untyped_value = convertToUntyped(value);
- }
- private:
- int convertToTyped(const string& value_to_convert)
- {
- int converted = 0;
- char *endptr = nullptr;
- converted = strtol(value_to_convert.c_str(),
- &endptr, 10);
- if (*endptr != '\0')
- {
- m_set = false;
- m_untyped_value = "";
- return 0;
- }
- return converted;
- }
- string convertToUntyped(const int& value_to_convert)
- {
- stringstream ss;
- ss << value_to_convert;
- return ss.str();
- }
- string getTypeName()
- {
- return "integer";
- }
- };
-
- class ZiprDoubleOption_t : public ZiprTypedOption_t<double>
- {
- public:
- ZiprDoubleOption_t(const string& key, const string& value = "")
- : ZiprTypedOption_t(zotZiprDoubleOptionType, key, value)
- {
- m_value = convertToTyped(value);
- }
- ZiprDoubleOption_t(const string& key, double value)
- : ZiprTypedOption_t(zotZiprDoubleOptionType, key, "")
- {
- m_value = value;
- m_untyped_value = convertToUntyped(value);
- }
- void setValue(double value)
- {
- m_value = value;
- m_untyped_value = convertToUntyped(value);
- }
- private:
- double convertToTyped(const string& value_to_convert)
- {
- double converted = 0.;
- char *endptr = nullptr;
- converted = strtof(value_to_convert.c_str(),
- &endptr);
- if (*endptr != '\0')
- {
- m_set = false;
- m_untyped_value = "";
- return 0;
- }
- return converted;
- }
- string convertToUntyped(const double& value_to_convert)
- {
- stringstream ss;
- ss << value_to_convert;
- return ss.str();
- }
- string getTypeName() {
- return "double";
- }
- };
-
- class ZiprOptionsNamespace_t : public set<ZiprOption_t*>
- {
- public:
- ZiprOptionsNamespace_t(const string& ns) : m_namespace(ns) {}
- string getNamespace()
- {
- return m_namespace;
- };
- void printNamespace();
- ZiprOption_t *optionByKey(const string& key);
- void addOption(ZiprOption_t *option);
- void printUsage(int tabs, ostream &out);
- bool areRequirementsMet();
- void mergeNamespace(ZiprOptionsNamespace_t*);
- private:
- string m_namespace;
- };
-
- class ZiprOptions_t
- {
- public:
- ZiprOptions_t(int argc, char **argv);
- void addNamespace(ZiprOptionsNamespace_t *);
- void printNamespaces();
- bool parse(ostream *error=&cout, ostream *warn=&cerr);
- ZiprOptionsNamespace_t *getNamespace(const string& );
- void printUsage(ostream &out);
- bool areRequirementsMet();
- private:
- vector<string> m_arguments;
- set<ZiprOptionsNamespace_t*> m_namespaces;
- };
-
-}
diff --git a/include/zipr-sdk b/include/zipr-sdk
index b1176fc5d4d1223c5073ef83922b9d527e570e49..d10f786415afa1653f12670b5bf6d86f62849fe0 100644
--- a/include/zipr-sdk
+++ b/include/zipr-sdk
@@ -17,8 +17,8 @@
#include <private-include/dollop.h>
#include <private-include/memory_space.h>
#include <private-include/dollop_man.h>
-#include <private-include/zipr_options.h>
-#include <private-include/zipr_plugin.h>
+#include <private-include/options.h>
+#include <private-include/plugin.h>
#include <private-include/zipr.h>
//