[cpp-sp] branch dev/4.0.0 updated: Provisional DDF support for 64-bit integers.
Scott Cantor
cantor.2 at osu.edu
Mon May 23 15:18:56 UTC 2022
This is an automated email from the git hooks/post-receive script.
scantor pushed a commit to branch dev/4.0.0
in repository cpp-sp.
View the commit online:
http://git.shibboleth.net/view/?p=cpp-sp.git;a=commit;h=eb95b12aa3899d4a50a6496385bbcba1dff5a375
The following commit(s) were added to refs/heads/dev/4.0.0 by this push:
new eb95b12a Provisional DDF support for 64-bit integers.
eb95b12a is described below
commit eb95b12aa3899d4a50a6496385bbcba1dff5a375
Author: Scott Cantor <cantor.2 at osu.edu>
AuthorDate: Mon May 23 11:18:52 2022 -0400
Provisional DDF support for 64-bit integers.
---
shibsp/remoting/ddf.h | 5 +++
shibsp/remoting/impl/ddf.cpp | 99 +++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 103 insertions(+), 1 deletion(-)
diff --git a/shibsp/remoting/ddf.h b/shibsp/remoting/ddf.h
index ad3c525a..cfa6d260 100644
--- a/shibsp/remoting/ddf.h
+++ b/shibsp/remoting/ddf.h
@@ -50,6 +50,7 @@ namespace shibsp {
DDF(const char* n);
DDF(const char* n, const char* val, bool safe=true);
DDF(const char* n, long val);
+ DDF(const char* n, long long val);
DDF(const char* n, double val);
DDF(const char* n, void* val);
@@ -64,6 +65,7 @@ namespace shibsp {
bool isempty() const;
bool isstring() const;
bool isint() const;
+ bool islong() const;
bool isfloat() const;
bool isstruct() const;
bool islist() const;
@@ -72,6 +74,7 @@ namespace shibsp {
// type conversion and value extraction
const char* string() const; // legal for str
long integer() const; // legal for all types
+ long long longinteger() const; // legal for all types
double floating() const; // legal for float
void* pointer() const; // legal for pointer
@@ -88,6 +91,8 @@ namespace shibsp {
DDF& string(double val);
DDF& integer(long val);
DDF& integer(const char* val);
+ DDF& longinteger(long long val);
+ DDF& longinteger(const char* val);
DDF& floating(double val);
DDF& floating(const char* val);
DDF& structure();
diff --git a/shibsp/remoting/impl/ddf.cpp b/shibsp/remoting/impl/ddf.cpp
index 4ca4d1df..6a14d48b 100644
--- a/shibsp/remoting/impl/ddf.cpp
+++ b/shibsp/remoting/impl/ddf.cpp
@@ -96,12 +96,14 @@ struct shibsp::ddf_body_t {
DDF_STRUCT,
DDF_LIST,
DDF_POINTER,
- DDF_STRING_UNSAFE
+ DDF_STRING_UNSAFE,
+ DDF_LONG
} type; // data type of node
union {
char* string;
long integer;
+ long long longinteger;
double floating;
void* pointer;
struct {
@@ -139,6 +141,13 @@ DDF::DDF(const char* n, long val)
integer(val);
}
+DDF::DDF(const char* n, long long val)
+{
+ m_handle=new(nothrow) ddf_body_t;
+ name(n);
+ longinteger(val);
+}
+
DDF::DDF(const char* n, double val)
{
m_handle=new(nothrow) ddf_body_t;
@@ -174,6 +183,8 @@ DDF DDF::copy() const
return DDF(m_handle->name,m_handle->value.string,(m_handle->type==ddf_body_t::DDF_STRING)); return DDF(m_handle->name,m_handle->value.string,(m_handle->type==ddf_body_t::DDF_STRING));
case ddf_body_t::DDF_INT:
return DDF(m_handle->name,m_handle->value.integer);
+ case ddf_body_t::DDF_LONG:
+ return DDF(m_handle->name,m_handle->value.longinteger);
case ddf_body_t::DDF_FLOAT:
return DDF(m_handle->name,m_handle->value.floating);
case ddf_body_t::DDF_POINTER:
@@ -248,6 +259,11 @@ bool DDF::isint() const
return m_handle ? (m_handle->type==ddf_body_t::DDF_INT) : false;
}
+bool DDF::islong() const
+{
+ return m_handle ? (m_handle->type==ddf_body_t::DDF_LONG) : false;
+}
+
bool DDF::isfloat() const
{
return m_handle ? (m_handle->type==ddf_body_t::DDF_FLOAT) : false;
@@ -279,6 +295,8 @@ long DDF::integer() const
switch(m_handle->type) {
case ddf_body_t::DDF_INT:
return m_handle->value.integer;
+ case ddf_body_t::DDF_LONG:
+ return m_handle->value.longinteger;
case ddf_body_t::DDF_FLOAT:
return static_cast<long>(m_handle->value.floating);
case ddf_body_t::DDF_STRING:
@@ -294,12 +312,37 @@ long DDF::integer() const
return 0;
}
+long long DDF::longinteger() const
+{
+ if (m_handle) {
+ switch(m_handle->type) {
+ case ddf_body_t::DDF_INT:
+ return m_handle->value.integer;
+ case ddf_body_t::DDF_LONG:
+ return m_handle->value.longinteger;
+ case ddf_body_t::DDF_FLOAT:
+ return static_cast<long long>(m_handle->value.floating);
+ case ddf_body_t::DDF_STRING:
+ case ddf_body_t::DDF_STRING_UNSAFE:
+ return m_handle->value.string ? atoll(m_handle->value.string) : 0;
+ case ddf_body_t::DDF_STRUCT:
+ case ddf_body_t::DDF_LIST:
+ return m_handle->value.children.count;
+ default:
+ break;
+ }
+ }
+ return 0;
+}
+
double DDF::floating() const
{
if (m_handle) {
switch(m_handle->type) {
case ddf_body_t::DDF_INT:
return m_handle->value.integer;
+ case ddf_body_t::DDF_LONG:
+ return m_handle->value.longinteger;
case ddf_body_t::DDF_FLOAT:
return m_handle->value.floating;
case ddf_body_t::DDF_STRING:
@@ -413,6 +456,24 @@ DDF& DDF::integer(const char* val)
return *this;
}
+DDF& DDF::longinteger(long long val)
+{
+ if (empty().m_handle) {
+ m_handle->value.longinteger=val;
+ m_handle->type=ddf_body_t::DDF_LONG;
+ }
+ return *this;
+}
+
+DDF& DDF::longinteger(const char* val)
+{
+ if (empty().m_handle) {
+ m_handle->value.longinteger=(val ? atoll(val) : 0);
+ m_handle->type=ddf_body_t::DDF_LONG;
+ }
+ return *this;
+}
+
DDF& DDF::floating(double val)
{
if (empty().m_handle) {
@@ -739,6 +800,14 @@ void DDF::dump(FILE* f, int indent) const
fprintf(f,"%ld",m_handle->value.integer);
break;
+ case ddf_body_t::DDF_LONG:
+ if (m_handle->name)
+ fprintf(f,"long long %s = ",m_handle->name);
+ else
+ fprintf(f,"long long = ");
+ fprintf(f,"%lld",m_handle->value.longinteger);
+ break;
+
case ddf_body_t::DDF_FLOAT:
if (m_handle->name)
fprintf(f,"double %s = ",m_handle->name);
@@ -825,6 +894,8 @@ void DDF::dump(FILE* f, int indent) const
5 32-bit count of children
DDF_STRING_UNSAFE:
7 URL-encoded string
+ DDF_LONG:
+ 8 64-bit integer
Pointers are collapsed into empty, so the type value of 6 is unused.
The distinction of unsafe strings allows for proper deserialization
@@ -860,6 +931,15 @@ static bool is32bitSafe(long what)
return (0 == upperOfuWhat);
}
+static bool is64bitSafe(long long what)
+{
+ if (sizeof(what) <= 8) return true;
+ unsigned long long uWhat = (what < 0) ? -what : what;
+ unsigned long long upperOfuWhat = uWhat >> 63;
+
+ return (0 == upperOfuWhat);
+}
+
void serialize(ddf_body_t* p, ostream& os)
{
if (p) {
@@ -892,6 +972,12 @@ void serialize(ddf_body_t* p, ostream& os)
os << ddf_body_t::DDF_INT << ' ' << p->value.integer << endl;
break;
+ case ddf_body_t::DDF_LONG:
+ if (!is64bitSafe(p->value.longinteger))
+ throw IOException("Integer Overflow");
+ os << ddf_body_t::DDF_LONG << ' ' << p->value.longinteger << endl;
+ break;
+
case ddf_body_t::DDF_FLOAT:
os << ddf_body_t::DDF_FLOAT << ' ' << setprecision(15) << fixed
<< p->value.floating << dec << endl;
@@ -1034,6 +1120,17 @@ DDF deserialize(istream& is)
}
break;
+ case ddf_body_t::DDF_LONG:
+ {
+ long long value = 0;
+ source >> value;
+ if (!source) {
+ return obj;
+ }
+ obj.longinteger(value);
+ }
+ break;
+
case ddf_body_t::DDF_FLOAT:
{
double value = 0;
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
More information about the commits
mailing list