From c9bfccc35345ce58fb5774d4b0b6a9868b262c0a Mon Sep 17 00:00:00 2001
From: giorgio <giorgio@13f79535-47bb-0310-9956-ffa450edef68>
Date: Wed, 5 Sep 2012 08:31:30 +0000
Subject: git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1381061
 13f79535-47bb-0310-9956-ffa450edef68

---
 sca-cpp/branches/lightweight-sca/kernel/value.hpp | 656 ++++++++++++++++++++++
 1 file changed, 656 insertions(+)
 create mode 100644 sca-cpp/branches/lightweight-sca/kernel/value.hpp

(limited to 'sca-cpp/branches/lightweight-sca/kernel/value.hpp')

diff --git a/sca-cpp/branches/lightweight-sca/kernel/value.hpp b/sca-cpp/branches/lightweight-sca/kernel/value.hpp
new file mode 100644
index 0000000000..206fe8b32b
--- /dev/null
+++ b/sca-cpp/branches/lightweight-sca/kernel/value.hpp
@@ -0,0 +1,656 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* $Rev$ $Date$ */
+
+#ifndef tuscany_value_hpp
+#define tuscany_value_hpp
+
+/**
+ * Generic value type.
+ */
+
+#include <stdlib.h>
+#include <apr_uuid.h>
+#include <apr_time.h>
+
+#include "string.hpp"
+#include "sstream.hpp"
+#include "gc.hpp"
+#include "function.hpp"
+#include "list.hpp"
+#include "monad.hpp"
+
+namespace tuscany
+{
+
+#ifdef WANT_MAINTAINER_COUNTERS
+
+/**
+ * Debug utilities. Counters used to track instances of values
+ */
+long int countValues = 0;
+long int countEValues = 0;
+long int countCValues = 0;
+long int countVValues = 0;
+
+bool resetValueCounters() {
+    countValues = countEValues = countCValues = countVValues = 0;
+    return true;
+}
+
+bool checkValueCounters() {
+    return countValues == 0;
+}
+
+bool printValueCounters() {
+    cout << "countValues " << countValues << endl;
+    cout << "countEValues " << countEValues << endl;
+    cout << "countCValues " << countCValues << endl;
+    cout << "countVValues " << countVValues << endl;
+    return true;
+}
+
+#else
+
+#define resetValueCounters()
+#define checkValueCounters() true
+#define printValueCounters()
+
+#endif
+
+#ifdef WANT_MAINTAINER_WATCH
+
+/**
+ * Debug utilities. Macro used to write the contents of a value to
+ * a string, easier to watch in a debugger than the value itself.
+ */
+
+#define debug_watchValue() do { \
+        this->watch = watchValue(*this); \
+    } while (0)
+
+#else
+
+#define debug_watchValue()
+
+#endif
+
+class value;
+
+class value {
+public:
+
+    enum ValueType {
+        Nil, Symbol, String, List, Number, Bool, Lambda, Ptr
+    };
+
+    value() : type(value::Nil) {
+        debug_inc(countValues);
+        debug_inc(countEValues);
+        debug_watchValue();
+    }
+
+    value(const value& v) {
+        debug_inc(countValues);
+        debug_inc(countCValues);
+        type = v.type;
+        switch(type) {
+        case value::List:
+            lst() = v.lst();
+        case value::Lambda:
+            func() = v.func();
+        case value::Symbol:
+            str() = v.str();
+        case value::String:
+            str() = v.str();
+        case value::Number:
+            num() = v.num();
+        case value::Bool:
+            boo() = v.boo();
+        case value::Ptr:
+            ptr() = v.ptr();
+        default:
+            break;
+        }
+#ifdef WANT_MAINTAINER_WATCH
+        watch = v.watch;
+#endif
+    }
+
+    virtual ~value() {
+        debug_dec(countValues);
+    }
+
+    value(const lambda<value(const list<value>&)>& func) : type(value::Lambda), data(vdata(func)) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const string& str) : type(value::String), data(vdata(result(str))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const char* str) : type(value::Symbol), data(vdata(result(string(str)))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const list<value>& lst) : type(value::List), data(vdata(result(lst))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const list<list<value> >& l) : type(value::List), data(vdata(result(listOfValues(l)))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const double num) : type(value::Number), data(vdata(result(num))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const int num) : type(value::Number), data(vdata(result((double)num))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const bool boo) : type(value::Bool), data(vdata(result(boo))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const gc_ptr<value> ptr) : type(value::Ptr), data(vdata(result(ptr))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const failable<value>& m) : type(value::List),
+        data(vdata(result(hasContent(m)? mklist<value>(content(m)) : rcode(m) == 1? mklist<value>(value(), reason(m)) : mklist<value>(value(), reason(m), rcode(m))))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    value(const maybe<value>& m) : type(value::List),
+        data(vdata(result(hasContent(m)? mklist<value>(content(m)) : list<value>()))) {
+        debug_inc(countValues);
+        debug_inc(countVValues);
+        debug_watchValue();
+    }
+
+    const value& operator=(const value& v) {
+        if(this == &v)
+            return *this;
+        type = v.type;
+        switch(type) {
+        case value::List:
+            lst() = v.lst();
+        case value::Lambda:
+            func() = v.func();
+        case value::Symbol:
+            str() = v.str();
+        case value::String:
+            str() = v.str();
+        case value::Number:
+            num() = v.num();
+        case value::Bool:
+            boo() = v.boo();
+        case value::Ptr:
+            ptr() = v.ptr();
+        default:
+            break;
+        }
+#ifdef WANT_MAINTAINER_WATCH
+        watch = v.watch;
+#endif
+        return *this;
+    }
+
+    const bool operator!=(const value& v) const {
+        return !this->operator==(v);
+    }
+
+    const bool operator==(const value& v) const {
+        if(this == &v)
+            return true;
+        switch(type) {
+        case value::Nil:
+            return v.type == value::Nil;
+        case value::List:
+            return v.type == value::List && lst()() == v.lst()();
+        case value::Lambda:
+            return v.type == value::Lambda && func() == v.func();
+        case value::Symbol:
+        case value::String:
+            return str()() == (string)v;
+        case value::Number:
+            return num()() == (double)v;
+        case value::Bool:
+            return boo()() == (bool)v;
+        case value::Ptr:
+            return v.type == value::Ptr && ptr()() == v.ptr()();
+        default:
+            return false;
+        }
+    }
+
+    const bool operator<(const value& v) const {
+        if(this == &v)
+            return false;
+        switch(type) {
+        case value::List:
+            return v.type == value::List && lst()() < v.lst()();
+        case value::Symbol:
+        case value::String:
+            return str()() < (string)v;
+        case value::Bool:
+            return boo()() < (bool)v;
+        case value::Number:
+            return num()() < (double)v;
+        default:
+            return false;
+        }
+    }
+
+    const bool operator>(const value& v) const {
+        if(this == &v)
+            return false;
+        switch(type) {
+        case value::List:
+            return v.type == value::List && lst()() > v.lst()();
+        case value::Symbol:
+        case value::String:
+            return str()() > (string)v;
+        case value::Bool:
+            return boo()() > (bool)v;
+        case value::Number:
+            return num()() > (double)v;
+        default:
+            return false;
+        }
+    }
+
+    const value operator()(const list<value>& args) const {
+        return func()(args);
+    }
+
+    operator const string() const {
+        switch(type) {
+        case value::Symbol:
+        case value::String:
+            return str()();
+        case value::Number: {
+            ostringstream os;
+            os << num()();
+            return tuscany::str(os);
+        }
+        case value::Bool:
+            return boo()()? trueString : falseString;
+        default:
+            return emptyString;
+        }
+    }
+
+    operator const double() const {
+        switch(type) {
+        case value::Symbol:
+        case value::String:
+            return atof(c_str(str()()));
+        case value::Number:
+            return (double)num()();
+        case value::Bool:
+            return boo()()? 1.0 : 0.0;
+        default:
+            return 0.0;
+        }
+    }
+
+    operator const int() const {
+        switch(type) {
+        case value::Symbol:
+        case value::String:
+            return atoi(c_str(str()()));
+        case value::Number:
+            return (int)num()();
+        case value::Bool:
+            return boo()()? 1 : 0;
+        default:
+            return 0;
+        }
+    }
+
+    operator const bool() const {
+        switch(type) {
+        case value::Symbol:
+        case value::String:
+            return str()() == string("true");
+        case value::Number:
+            return (int)num()() != 0;
+        case value::Bool:
+            return boo()();
+        default:
+            return 0;
+        }
+    }
+
+    operator const gc_ptr<value>() const {
+        return ptr()();
+    }
+
+    operator const list<value>() const {
+        return lst()();
+    }
+
+    operator const list<list<value> >() const {
+        return listOfListOfValues(lst()());
+    }
+
+    operator const lambda<value(const list<value>&)>() const {
+        return func();
+    }
+
+private:
+     template<typename T> lambda<T>& vdata() const {
+        return *reinterpret_cast<lambda<T> *> (const_cast<lambda<char()> *> (&data));
+    }
+
+    template<typename T> const lambda<char()>& vdata(const T& v) const {
+        return *reinterpret_cast<const lambda<char()> *> (&v);
+    }
+
+    lambda<double()>& num() const {
+        return vdata<double()> ();
+    }
+
+    lambda<bool()>& boo() const {
+        return vdata<bool()> ();
+    }
+
+    lambda<gc_ptr<value>()>& ptr() const {
+        return vdata<gc_ptr<value>()> ();
+    }
+
+    lambda<string()>& str() const {
+        return vdata<string()> ();
+    }
+
+    lambda<list<value>()>& lst() const {
+        return vdata<list<value>()> ();
+    }
+
+    lambda<value(const list<value>&)>& func() const {
+        return vdata<value(const list<value>&)> ();
+    }
+
+    const list<value> listOfValues(const list<list<value> >& l) const {
+        if (isNil(l))
+            return list<value>();
+        return cons<value>(car(l), listOfValues(cdr(l)));
+    }
+
+    const list<list<value> > listOfListOfValues(const list<value>& l) const {
+        if (isNil(l))
+            return list<list<value> >();
+        return cons<list<value> >(list<value>(car(l)), listOfListOfValues(cdr(l)));
+    }
+
+    friend ostream& operator<<(ostream&, const value&);
+    friend const value::ValueType type(const value& v);
+
+#ifdef WANT_MAINTAINER_WATCH
+    friend const string watchValue(const value& v);
+    string watch;
+#endif
+
+    ValueType type;
+     lambda<char()> data;
+};
+
+#ifdef WANT_MAINTAINER_WATCH
+
+/**
+ * Debug utility used to write the contents of a value to a string, easier
+ * to watch than the value itself in a debugger.
+ */
+const string watchValue(const value& v) {
+    if (v.type == value::List)
+        return watchList<value>(v);
+    odebugstream os;
+    os << v;
+    return str(os);
+}
+
+#endif
+
+/**
+ * Write an escape string to a buffer.
+ */
+const char* escapestr(const char* s, char* buf) {
+    if (*s == '\0') {
+        *buf = '\0';
+        return buf;
+    }
+    if (*s == '\\' || *s == '"') {
+        *buf = '\\';
+        *(buf + 1) = *s;
+        return escapestr(s + 1, buf + 2);
+    }
+    *buf = *s;
+    return escapestr(s + 1, buf + 1);
+}
+
+/**
+ * Write an escaped string value to a stream.
+ */
+ostream& escvwrite(const string& str, ostream& out) {
+    char* buf = gc_cnew(length(str) * 2 + 1);
+    escapestr(c_str(str), buf);
+    out << buf;
+    return out;
+}
+
+/**
+ * Write a value to a stream.
+ */
+ostream& operator<<(ostream& out, const value& v) {
+    switch(v.type) {
+    case value::List:
+        return out << v.lst()();
+    case value::Lambda:
+        return out << "lambda::" << v.func();
+    case value::Symbol:
+        return out << v.str()();
+    case value::String:
+        out << '\"';
+        escvwrite(v.str()(), out);
+        return out << '\"';
+    case value::Number:
+        return out << v.num()();
+    case value::Bool:
+        if(v.boo()())
+            return out << "true";
+        else
+            return out << "false";
+    case value::Ptr: {
+        const gc_ptr<value> p =  v.ptr()();
+        if (p == gc_ptr<value>(NULL))
+            return out << "gc_ptr::null";
+        return out << "gc_ptr::" << p;
+    }
+    default:
+        return out << "nil";
+    }
+}
+
+/**
+ * Returns the type of a value.
+ */
+const value::ValueType type(const value& v) {
+    return v.type;
+}
+
+/**
+ * Returns true if a value is nil.
+ */
+const bool isNil(const value& v) {
+    return type(v) == value::Nil;
+}
+
+/**
+ * Returns true if a value is a lambda.
+ */
+const bool isLambda(const value& v) {
+    return type(v) == value::Lambda;
+}
+
+/**
+ * Returns true if a value is a string.
+ */
+const bool isString(const value& v) {
+    return type(v) == value::String;
+}
+
+/**
+ * Returns true if a value is a symbol.
+ */
+const bool isSymbol(const value& v) {
+    return type(v) == value::Symbol;
+}
+
+/**
+ * Returns true if a value is a list.
+ */
+const bool isList(const value& v) {
+    return type(v) == value::List;
+}
+
+/**
+ * Returns true if a value is a number.
+ */
+const bool isNumber(const value& v) {
+    return type(v) == value::Number;
+}
+
+/**
+ * Returns true if a value is a boolean.
+ */
+const bool isBool(const value& v) {
+    return type(v) == value::Bool;
+}
+
+/**
+ * Returns true if a value is a pointer.
+ */
+const bool isPtr(const value& v) {
+    return type(v) == value::Ptr;
+}
+
+/**
+ * Returns true if a value is a tagged list.
+ */
+const bool isTaggedList(const value& exp, value tag) {
+    if(isList(exp) && !isNil((list<value>)exp))
+        return car((list<value>)exp) == tag;
+    return false;
+}
+
+/**
+ * Make a list of values from a list of other things.
+ */
+template<typename T> const list<value> mkvalues(const list<T>& l) {
+    if (isNil(l))
+        return list<value>();
+    return cons<value>(car(l), mkvalues(cdr(l)));
+}
+
+/**
+ * Convert a list of values to a list of other things.
+ */
+template<typename T> const list<T> convertValues(const list<value>& l) {
+    if (isNil(l))
+        return list<T>();
+    return cons<T>(car(l), convertValues<T>(cdr(l)));
+}
+
+/**
+ * Convert a path string value to a list of values.
+ */
+const list<string> pathTokens(const char* p) {
+    if (p == NULL || p[0] == '\0')
+        return list<string>();
+    if (p[0] == '/')
+        return tokenize("/", p + 1);
+    return tokenize("/", p);
+}
+
+const list<value> pathValues(const value& p) {
+    return mkvalues(pathTokens(c_str(p)));
+}
+
+/**
+ * Convert a path represented as a list of values to a string value.
+ */
+const value path(const list<value>& p) {
+    if (isNil(p))
+        return "";
+    return string("/") + car(p) + path(cdr(p));
+}
+
+/**
+ * Make a uuid value.
+ */
+const value mkuuid() {
+    apr_uuid_t id;
+    apr_uuid_get(&id);
+    char buf[APR_UUID_FORMATTED_LENGTH];
+    apr_uuid_format(buf, &id);
+    return value(string(buf, APR_UUID_FORMATTED_LENGTH));
+}
+
+/**
+ * Make a random alphanumeric value.
+ */
+const int intrand() {
+    const apr_uint64_t now = apr_time_now();
+    srand((unsigned int)(((now >> 32) ^ now) & 0xffffffff));
+    return rand() & 0x0FFFF;
+}       
+
+const value mkrand() {
+    char buf[32];
+    const char* an = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    for (int i =0; i < 32; i++)
+        buf[i] = an[intrand() % 62];
+    return value(string(buf, 32));
+}
+
+}
+#endif /* tuscany_value_hpp */
-- 
cgit v1.2.3