diff options
Diffstat (limited to 'sca-cpp/trunk/modules')
23 files changed, 750 insertions, 712 deletions
diff --git a/sca-cpp/trunk/modules/Makefile.am b/sca-cpp/trunk/modules/Makefile.am index 44ddf85de4..3b2d60b93a 100644 --- a/sca-cpp/trunk/modules/Makefile.am +++ b/sca-cpp/trunk/modules/Makefile.am @@ -15,7 +15,7 @@ # specific language governing permissions and limitations # under the License. -SUBDIRS = atom eval http json scdl server +SUBDIRS = atom eval json scdl http server includedir = $(prefix)/include/modules nobase_include_HEADERS = */*.hpp diff --git a/sca-cpp/trunk/modules/atom/atom-test.cpp b/sca-cpp/trunk/modules/atom/atom-test.cpp index ba651e8eb2..560c383a23 100644 --- a/sca-cpp/trunk/modules/atom/atom-test.cpp +++ b/sca-cpp/trunk/modules/atom/atom-test.cpp @@ -24,21 +24,19 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "atom.hpp" namespace tuscany { namespace atom { -std::ostringstream* writer(const std::string& s, std::ostringstream* os) { +ostream* writer(const string& s, ostream* os) { (*os) << s; return os; } -std::string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">item</title>" "<id>cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b</id>" @@ -50,7 +48,7 @@ std::string itemEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<link href=\"cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b\"/>" "</entry>\n"); -std::string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" +string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title>item</title><content type=\"text/xml\">" "<Item xmlns=\"http://services/\">" "<name xmlns=\"\">Orange</name>" @@ -59,7 +57,7 @@ std::string incompleteEntry("<entry xmlns=\"http://www.w3.org/2005/Atom\">" "</content>" "</entry>"); -std::string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<entry xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">item</title>" "<id></id>" @@ -73,36 +71,36 @@ std::string completedEntry("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" bool testEntry() { { - const list<value> i = list<value>() << element << "item" - << (list<value>() << element << "name" << std::string("Apple")) - << (list<value>() << element << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemEntry); + const list<value> i = list<value>() + element + value("item") + + value(list<value>() + element + value("name") + value(string("Apple"))) + + value(list<value>() + element + value("price") + value(string("$2.99"))); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == itemEntry); } { const list<value> a = content(readEntry(mklist(itemEntry))); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemEntry); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == itemEntry); } { const list<value> a = content(readEntry(mklist(incompleteEntry))); - std::ostringstream os; - writeATOMEntry<std::ostringstream*>(writer, &os, a); - assert(os.str() == completedEntry); + ostringstream os; + writeATOMEntry<ostream*>(writer, &os, a); + assert(str(os) == completedEntry); } return true; } -std::string emptyFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string emptyFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<feed xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">Feed</title>" "<id>1234</id>" "</feed>\n"); -std::string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<feed xmlns=\"http://www.w3.org/2005/Atom\">" "<title type=\"text\">Feed</title>" "<id>1234</id>" @@ -130,51 +128,51 @@ std::string itemFeed("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" bool testFeed() { { - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, mklist<value>("Feed", "1234")); - assert(os.str() == emptyFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, mklist<value>("Feed", "1234")); + assert(str(os) == emptyFeed); } { const list<value> a = content(readFeed(mklist(emptyFeed))); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == emptyFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == emptyFeed); } { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << (list<value>() << element << "item" - << (list<value>() << element << "name" << "Apple") - << (list<value>() << element << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << (list<value>() << element << "item" - << (list<value>() << element << "name" << "Orange") - << (list<value>() << element << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + (list<value>() + element + "item" + + (list<value>() + element + "name" + "Apple") + + (list<value>() + element + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + (list<value>() + element + "item" + + (list<value>() + element + "name" + "Orange") + + (list<value>() + element + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("1234", i)); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << valueToElement(list<value>() << "item" - << (list<value>() << "name" << "Apple") - << (list<value>() << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << valueToElement(list<value>() << "item" - << (list<value>() << "name" << "Orange") - << (list<value>() << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + valueToElement(list<value>() + "item" + + (list<value>() + "name" + "Apple") + + (list<value>() + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + valueToElement(list<value>() + "item" + + (list<value>() + "name" + "Orange") + + (list<value>() + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("1234", i)); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } { const list<value> a = content(readFeed(mklist(itemFeed))); - std::ostringstream os; - writeATOMFeed<std::ostringstream*>(writer, &os, a); - assert(os.str() == itemFeed); + ostringstream os; + writeATOMFeed<ostream*>(writer, &os, a); + assert(str(os) == itemFeed); } return true; } @@ -183,12 +181,12 @@ bool testFeed() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::atom::testEntry(); tuscany::atom::testFeed(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/atom/atom.hpp b/sca-cpp/trunk/modules/atom/atom.hpp index 7e2eb66cd2..4dbf7c7728 100644 --- a/sca-cpp/trunk/modules/atom/atom.hpp +++ b/sca-cpp/trunk/modules/atom/atom.hpp @@ -26,7 +26,7 @@ * ATOM data conversion functions. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "monad.hpp" @@ -40,9 +40,9 @@ namespace atom { */ const list<value> entryValues(const list<value>& e) { const list<value> lt = filter<value>(selector(mklist<value>(element, "title")), e); - const value t = isNil(lt)? value(std::string("")) : elementValue(car(lt)); + const value t = isNil(lt)? value(emptyString) : elementValue(car(lt)); const list<value> li = filter<value>(selector(mklist<value>(element, "id")), e); - const value i = isNil(li)? value(std::string("")) : elementValue(car(li)); + const value i = isNil(li)? value(emptyString) : elementValue(car(li)); const list<value> lc = filter<value>(selector(mklist<value>(element, "content")), e); return mklist<value>(t, i, cadr(elementChildren(car(lc)))); } @@ -59,10 +59,10 @@ const list<value> entriesValues(const list<value>& e) { /** * Convert a list of strings to a list of values representing an ATOM entry. */ -const failable<list<value>, std::string> readEntry(const list<std::string>& ilist) { +const failable<list<value> > readEntry(const list<string>& ilist) { const list<value> e = readXML(ilist); if (isNil(e)) - return mkfailure<list<value>, std::string>("Empty entry"); + return mkfailure<list<value> >("Empty entry"); return entryValues(car(e)); } @@ -77,10 +77,10 @@ const value entryValue(const list<value>& e) { /** * Convert a list of strings to a list of values representing an ATOM feed. */ -const failable<list<value>, std::string> readFeed(const list<std::string>& ilist) { +const failable<list<value> > readFeed(const list<string>& ilist) { const list<value> f = readXML(ilist); if (isNil(f)) - return mkfailure<list<value>, std::string>("Empty feed"); + return mkfailure<list<value> >("Empty feed"); const list<value> t = filter<value>(selector(mklist<value>(element, "title")), car(f)); const list<value> i = filter<value>(selector(mklist<value>(element, "id")), car(f)); const list<value> e = filter<value>(selector(mklist<value>(element, "entry")), car(f)); @@ -95,11 +95,11 @@ const failable<list<value>, std::string> readFeed(const list<std::string>& ilist */ const list<value> entryElement(const list<value>& l) { return list<value>() - << element << "entry" << (list<value>() << attribute << "xmlns" << "http://www.w3.org/2005/Atom") - << (list<value>() << element << "title" << (list<value>() << attribute << "type" << "text") << car(l)) - << (list<value>() << element << "id" << cadr(l)) - << (list<value>() << element << "content" << (list<value>() << attribute << "type" << "application/xml") << caddr(l)) - << (list<value>() << element << "link" << (list<value>() << attribute << "href" << cadr(l))); + + element + "entry" + (list<value>() + attribute + "xmlns" + "http://www.w3.org/2005/Atom") + + (list<value>() + element + "title" + (list<value>() + attribute + "type" + "text") + car(l)) + + (list<value>() + element + "id" + cadr(l)) + + (list<value>() + element + "content" + (list<value>() + attribute + "type" + "application/xml") + caddr(l)) + + (list<value>() + element + "link" + (list<value>() + attribute + "href" + cadr(l))); } /** @@ -115,26 +115,26 @@ const list<value> entriesElements(const list<value>& l) { * Convert a list of values representing an ATOM entry to an ATOM entry. * The first two values in the list are the entry id and title. */ -template<typename R> const failable<R, std::string> writeATOMEntry(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l) { +template<typename R> const failable<R> writeATOMEntry(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l) { return writeXML<R>(reduce, initial, mklist<value>(entryElement(l))); } -const failable<list<std::string>, std::string> writeATOMEntry(const list<value>& l) { - const failable<list<std::string>, std::string> ls = writeATOMEntry<list<std::string> >(rcons<std::string>, list<std::string>(), l); +const failable<list<string> > writeATOMEntry(const list<value>& l) { + const failable<list<string> > ls = writeATOMEntry<list<string> >(rcons<string>, list<string>(), l); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** * Convert a list of values representing an ATOM feed to an ATOM feed. * The first two values in the list are the feed id and title. */ -template<typename R> const failable<R, std::string> writeATOMFeed(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l) { +template<typename R> const failable<R> writeATOMFeed(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l) { const list<value> f = list<value>() - << element << "feed" << (list<value>() << attribute << "xmlns" << "http://www.w3.org/2005/Atom") - << (list<value>() << element << "title" << (list<value>() << attribute << "type" << "text") << car(l)) - << (list<value>() << element << "id" << cadr(l)); + + element + "feed" + (list<value>() + attribute + "xmlns" + "http://www.w3.org/2005/Atom") + + (list<value>() + element + "title" + (list<value>() + attribute + "type" + "text") + car(l)) + + (list<value>() + element + "id" + cadr(l)); if (isNil(cddr(l))) return writeXML<R>(reduce, initial, mklist<value>(f)); const list<value> fe = append(f, entriesElements(cddr(l))); @@ -145,11 +145,11 @@ template<typename R> const failable<R, std::string> writeATOMFeed(const lambda<R * Convert a list of values representing an ATOM feed to a list of strings. * The first two values in the list are the feed id and title. */ -const failable<list<std::string>, std::string> writeATOMFeed(const list<value>& l) { - const failable<list<std::string>, std::string> ls = writeATOMFeed<list<std::string> >(rcons<std::string>, list<std::string>(), l); +const failable<list<string> > writeATOMFeed(const list<value>& l) { + const failable<list<string> > ls = writeATOMFeed<list<string>>(rcons<string>, list<string>(), l); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** diff --git a/sca-cpp/trunk/modules/eval/driver.hpp b/sca-cpp/trunk/modules/eval/driver.hpp index 3076e677c4..2d1badf501 100644 --- a/sca-cpp/trunk/modules/eval/driver.hpp +++ b/sca-cpp/trunk/modules/eval/driver.hpp @@ -26,34 +26,34 @@ * Script evaluator main driver loop. */ -#include <string> -#include <iostream> +#include "string.hpp" +#include "stream.hpp" #include "eval.hpp" namespace tuscany { namespace eval { -const std::string evalOutputPrompt("; "); -const std::string evalInputPrompt("=> "); +const string evalOutputPrompt("; "); +const string evalInputPrompt("=> "); -const bool promptForInput(const std::string str, std::ostream& out) { - out << std::endl << std::endl << str; +const bool promptForInput(const string& str, ostream& out) { + out << endl << endl << str; return true; } -const bool announceOutput(const std::string str, std::ostream& out) { - out << std::endl << str; +const bool announceOutput(const string str, ostream& out) { + out << endl << str; return true; } -const bool userPrint(const value val, std::ostream& out) { +const bool userPrint(const value val, ostream& out) { if(isCompoundProcedure(val)) writeValue(mklist<value>(compoundProcedureSymbol, procedureParameters(val), procedureBody(val), "<procedure-env>"), out); writeValue(val, out); return true; } -const value evalDriverLoop(std::istream& in, std::ostream& out, Env& globalEnv, const gc_pool& pool) { +const value evalDriverLoop(istream& in, ostream& out, Env& globalEnv, const gc_pool& pool) { promptForInput(evalInputPrompt, out); value input = readValue(in); if (isNil(input)) @@ -64,8 +64,7 @@ const value evalDriverLoop(std::istream& in, std::ostream& out, Env& globalEnv, return evalDriverLoop(in, out, globalEnv, pool); } -const bool evalDriverRun(std::istream& in, std::ostream& out) { - gc_pool pool; +const bool evalDriverRun(istream& in, ostream& out, const gc_pool& pool) { setupDisplay(out); Env globalEnv = setupEnvironment(pool); evalDriverLoop(in, out, globalEnv, pool); diff --git a/sca-cpp/trunk/modules/eval/environment.hpp b/sca-cpp/trunk/modules/eval/environment.hpp index 3a19c01deb..29bb3b64da 100644 --- a/sca-cpp/trunk/modules/eval/environment.hpp +++ b/sca-cpp/trunk/modules/eval/environment.hpp @@ -26,10 +26,11 @@ * Script evaluator environment implementation. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "primitive.hpp" +#include <string> namespace tuscany { namespace eval { @@ -63,7 +64,7 @@ const Env enclosingEnvironment(const Env& env) { return cdr(env); } -const gc_pool_ptr<Frame> firstFrame(const Env& env) { +const gc_ptr<Frame> firstFrame(const Env& env) { return car(env); } @@ -82,7 +83,7 @@ const bool isDotVariable(const value& var) { const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, const list<value> values) { if (isNil(variables)) { if (!isNil(values)) - logStream() << "Too many arguments supplied " << values << std::endl; + logStream() << "Too many arguments supplied " << values << endl; return frameSoFar; } if (isDotVariable(car(variables))) @@ -90,7 +91,7 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c if (isNil(values)) { if (!isNil(variables)) - logStream() << "Too few arguments supplied " << variables << std::endl; + logStream() << "Too few arguments supplied " << variables << endl; return frameSoFar; } @@ -101,8 +102,8 @@ const Frame makeBinding(const Frame& frameSoFar, const list<value>& variables, c return makeBinding(newFrame, cdr(variables), cdr(values)); } -const gc_pool_ptr<Frame> makeFrame(const list<value>& variables, const list<value> values, const gc_pool& pool) { - gc_pool_ptr<Frame> frame = gc_pool_new<Frame>(pool); +const gc_ptr<Frame> makeFrame(const list<value>& variables, const list<value> values, const gc_pool& pool) { + gc_ptr<Frame> frame = new (gc_new<Frame>(pool)) Frame(); *frame = value(makeBinding(cons(value(list<value>()), list<value>()), variables, values)); return frame; } @@ -163,7 +164,7 @@ const value lookupEnvScan(const value& var, const list<value>& vars, const list< const value lookupEnvLoop(const value& var, const Env& env) { if(env == theEmptyEnvironment()) { - logStream() << "Unbound variable " << var << std::endl; + logStream() << "Unbound variable " << var << endl; return value(); } return lookupEnvScan(var, frameVariables(*firstFrame(env)), frameValues(*firstFrame(env)), env); diff --git a/sca-cpp/trunk/modules/eval/eval-shell.cpp b/sca-cpp/trunk/modules/eval/eval-shell.cpp index e1c90101da..f73ac61250 100644 --- a/sca-cpp/trunk/modules/eval/eval-shell.cpp +++ b/sca-cpp/trunk/modules/eval/eval-shell.cpp @@ -24,12 +24,13 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "gc.hpp" +#include "stream.hpp" +#include "string.hpp" #include "driver.hpp" int main() { - tuscany::eval::evalDriverRun(std::cin, std::cout); + tuscany::gc_scoped_pool pool; + tuscany::eval::evalDriverRun(tuscany::cin, tuscany::cout, pool); return 0; } diff --git a/sca-cpp/trunk/modules/eval/eval-test.cpp b/sca-cpp/trunk/modules/eval/eval-test.cpp index fb755b9077..3cf16f602f 100644 --- a/sca-cpp/trunk/modules/eval/eval-test.cpp +++ b/sca-cpp/trunk/modules/eval/eval-test.cpp @@ -24,16 +24,15 @@ */ #include <assert.h> -#include <iostream> -#include <string> -#include <sstream> +#include "stream.hpp" +#include "string.hpp" #include "driver.hpp" namespace tuscany { namespace eval { bool testEnv() { - gc_pool pool; + gc_scoped_pool pool; Env globalEnv = list<value>(); Env env = extendEnvironment(mklist<value>("a"), mklist<value>(1), globalEnv, pool); defineVariable("x", env, env); @@ -50,26 +49,23 @@ bool testEnvGC() { assert(checkValueCounters()); assert(checkLambdaCounters()); assert(checkListCounters()); - //printLambdaCounters(); - //printListCounters(); - //printValueCounters(); return true; } bool testRead() { - std::istringstream is("abcd"); + istringstream is("abcd"); assert(readValue(is) == "abcd"); - std::istringstream is2("123"); + istringstream is2("123"); assert(readValue(is2) == value(123)); - std::istringstream is3("(abcd)"); + istringstream is3("(abcd)"); assert(readValue(is3) == mklist(value("abcd"))); - std::istringstream is4("(abcd xyz)"); + istringstream is4("(abcd xyz)"); assert(readValue(is4) == mklist<value>("abcd", "xyz")); - std::istringstream is5("(abcd (xyz tuv))"); + istringstream is5("(abcd (xyz tuv))"); assert(readValue(is5) == mklist<value>("abcd", mklist<value>("xyz", "tuv"))); return true; @@ -77,43 +73,43 @@ bool testRead() { bool testWrite() { const list<value> i = list<value>() - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" - << (list<value>() << "item" - << (list<value>() << "name" << "Apple") - << (list<value>() << "price" << "$2.99"))) - << (list<value>() << "item" << "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" - << (list<value>() << "item" - << (list<value>() << "name" << "Orange") - << (list<value>() << "price" << "$3.55"))); + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b" + + (list<value>() + "item" + + (list<value>() + "name" + "Apple") + + (list<value>() + "price" + "$2.99"))) + + (list<value>() + "item" + "cart-53d67a61-aa5e-4e5e-8401-39edeba8b83c" + + (list<value>() + "item" + + (list<value>() + "name" + "Orange") + + (list<value>() + "price" + "$3.55"))); const list<value> a = cons<value>("Feed", cons<value>("feed-1234", i)); - std::ostringstream os; + ostringstream os; writeValue(a, os); - std::istringstream is(os.str()); + istringstream is(str(os)); assert(readValue(is) == a); return true; } -const std::string testSchemeNumber( +const string testSchemeNumber( "(define (testNumber) (if (= 1 1) (display \"testNumber ok\") (error \"testNumber\"))) " "(testNumber)"); -const std::string testSchemeString( +const string testSchemeString( "(define (testString) (if (= \"abc\" \"abc\") (display \"testString ok\") (error \"testString\"))) " "(testString)"); -const std::string testSchemeDefinition( +const string testSchemeDefinition( "(define a \"abc\") (define (testDefinition) (if (= a \"abc\") (display \"testDefinition ok\") (error \"testDefinition\"))) " "(testDefinition)"); -const std::string testSchemeIf( +const string testSchemeIf( "(define (testIf) (if (= \"abc\" \"abc\") (if (= \"xyz\" \"xyz\") (display \"testIf ok\") (error \"testNestedIf\")) (error \"testIf\"))) " "(testIf)"); -const std::string testSchemeCond( +const string testSchemeCond( "(define (testCond) (cond ((= \"abc\" \"abc\") (display \"testCond ok\")) (else (error \"testIf\"))))" "(testCond)"); -const std::string testSchemeBegin( +const string testSchemeBegin( "(define (testBegin) " "(begin " "(define a \"abc\") " @@ -124,42 +120,39 @@ const std::string testSchemeBegin( ") " "(testBegin)"); -const std::string testSchemeLambda( +const string testSchemeLambda( "(define sqrt (lambda (x) (* x x))) " "(define (testLambda) (if (= 4 (sqrt 2)) (display \"testLambda ok\") (error \"testLambda\"))) " "(testLambda)"); -const std::string testSchemeForward( +const string testSchemeForward( "(define (testLambda) (if (= 4 (sqrt 2)) (display \"testForward ok\") (error \"testForward\"))) " "(define sqrt (lambda (x) (* x x))) " "(testLambda)"); -bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -const std::string evalOutput(const std::string& scm) { - std::istringstream is(scm); - std::ostringstream os; - evalDriverRun(is, os); - return os.str(); +const string evalOutput(const string& scm, const gc_pool& pool) { + istringstream is(scm); + ostringstream os; + evalDriverRun(is, os, pool); + return str(os); } bool testEval() { - assert(contains(evalOutput(testSchemeNumber), "testNumber ok")); - assert(contains(evalOutput(testSchemeString), "testString ok")); - assert(contains(evalOutput(testSchemeDefinition), "testDefinition ok")); - assert(contains(evalOutput(testSchemeIf), "testIf ok")); - assert(contains(evalOutput(testSchemeCond), "testCond ok")); - assert(contains(evalOutput(testSchemeBegin), "testBegin1 ok")); - assert(contains(evalOutput(testSchemeBegin), "testBegin2 ok")); - assert(contains(evalOutput(testSchemeLambda), "testLambda ok")); - assert(contains(evalOutput(testSchemeForward), "testForward ok")); + gc_scoped_pool pool; + assert(contains(evalOutput(testSchemeNumber, pool), "testNumber ok")); + assert(contains(evalOutput(testSchemeString, pool), "testString ok")); + assert(contains(evalOutput(testSchemeDefinition, pool), "testDefinition ok")); + assert(contains(evalOutput(testSchemeIf, pool), "testIf ok")); + assert(contains(evalOutput(testSchemeCond, pool), "testCond ok")); + assert(contains(evalOutput(testSchemeBegin, pool), "testBegin1 ok")); + assert(contains(evalOutput(testSchemeBegin, pool), "testBegin2 ok")); + assert(contains(evalOutput(testSchemeLambda, pool), "testLambda ok")); + assert(contains(evalOutput(testSchemeForward, pool), "testForward ok")); return true; } bool testEvalExpr() { - gc_pool pool; + gc_scoped_pool pool; const value exp = mklist<value>("+", 2, 3); Env env = setupEnvironment(pool); const value r = evalExpr(exp, env, pool); @@ -168,7 +161,8 @@ bool testEvalExpr() { } bool testEvalRun() { - evalDriverRun(std::cin, std::cout); + gc_scoped_pool pool; + evalDriverRun(cin, cout, pool); return true; } @@ -178,26 +172,26 @@ const value mult(const list<value>& args) { return x * y; } -const std::string testReturnLambda( +const string testReturnLambda( "(define (testReturnLambda) * )"); -const std::string testCallLambda( +const string testCallLambda( "(define (testCallLambda l x y) (l x y))"); bool testEvalLambda() { - gc_pool pool; + gc_scoped_pool pool; Env env = setupEnvironment(pool); const value trl = mklist<value>("testReturnLambda"); - std::istringstream trlis(testReturnLambda); + istringstream trlis(testReturnLambda); const value trlv = evalScript(trl, trlis, env, pool); - std::istringstream tclis(testCallLambda); + istringstream tclis(testCallLambda); const value tcl = cons<value>("testCallLambda", quotedParameters(mklist<value>(trlv, 2, 3))); const value tclv = evalScript(tcl, tclis, env, pool); assert(tclv == value(6)); - std::istringstream tcelis(testCallLambda); + istringstream tcelis(testCallLambda); const value tcel = cons<value>("testCallLambda", quotedParameters(mklist<value>(primitiveProcedure(mult), 3, 4))); const value tcelv = evalScript(tcel, tcelis, env, pool); assert(tcelv == value(12)); @@ -214,9 +208,6 @@ bool testEvalGC() { assert(checkValueCounters()); assert(checkLambdaCounters()); assert(checkListCounters()); - //printLambdaCounters(); - //printListCounters(); - //printValueCounters(); return true; } @@ -224,7 +215,7 @@ bool testEvalGC() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::eval::testEnv(); tuscany::eval::testEnvGC(); @@ -235,6 +226,6 @@ int main() { tuscany::eval::testEvalLambda(); tuscany::eval::testEvalGC(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/eval/eval.hpp b/sca-cpp/trunk/modules/eval/eval.hpp index 1b4d94c631..ea6e2da13a 100644 --- a/sca-cpp/trunk/modules/eval/eval.hpp +++ b/sca-cpp/trunk/modules/eval/eval.hpp @@ -146,7 +146,7 @@ const value applyProcedure(const value& procedure, list<value>& arguments, const Env env = extendEnvironment(procedureParameters(procedure), arguments, procedureEnvironment(procedure), pool); return evalSequence(procedureBody(procedure), env, pool); } - logStream() << "Unknown procedure type " << procedure << std::endl; + logStream() << "Unknown procedure type " << procedure << endl; return value(); } @@ -208,7 +208,7 @@ const value expandClauses(const list<value>& clauses) { if(isCondElseClause(first)) { if(isNil(rest)) return sequenceToExp(condActions(first)); - logStream() << "else clause isn't last " << clauses << std::endl; + logStream() << "else clause isn't last " << clauses << endl; return value(); } return makeIf(condPredicate(first), sequenceToExp(condActions(first)), expandClauses(rest)); @@ -254,7 +254,7 @@ const value evalExpr(const value& exp, Env& env, const gc_pool& pool) { list<value> operandValues = listOfValues(operands(exp), env, pool); return applyProcedure(evalExpr(operat(exp), env, pool), operandValues, pool); } - logStream() << "Unknown expression type " << exp << std::endl; + logStream() << "Unknown expression type " << exp << endl; return value(); } @@ -281,7 +281,7 @@ const value evalScript(const value& expr, const value& script, Env& env, const g /** * Evaluate an expression against a script provided as an input stream. */ -const value evalScript(const value& expr, std::istream& is, Env& env, const gc_pool& pool) { +const value evalScript(const value& expr, istream& is, Env& env, const gc_pool& pool) { return evalScript(expr, readScript(is), env, pool); } diff --git a/sca-cpp/trunk/modules/eval/io.hpp b/sca-cpp/trunk/modules/eval/io.hpp index 53657ce055..0c2abb3af9 100644 --- a/sca-cpp/trunk/modules/eval/io.hpp +++ b/sca-cpp/trunk/modules/eval/io.hpp @@ -26,10 +26,9 @@ * Script evaluator IO functions. */ -#include <iostream> -#include <string> -#include <sstream> #include <ctype.h> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" #include "value.hpp" @@ -42,11 +41,8 @@ const value rightParenthesis(mklist<value>(")")); const value leftParenthesis(mklist<value>("(")); const value comment(mklist<value>(";")); -const double stringToNumber(const std::string& str) { - double d; - std::istringstream is(str); - is >> d; - return d; +const double stringToNumber(const string& str) { + return atof(c_str(str)); } const bool isWhitespace(const char ch) { @@ -73,18 +69,18 @@ const bool isRightParenthesis(const value& token) { return rightParenthesis == token; } -const char readChar(std::istream& in) { +const char readChar(istream& in) { if(in.eof()) { return -1; } - char c = (char)in.get(); + char c = (char)get(in); return c; } -const char peekChar(std::istream& in) { - if(in.eof()) +const char peekChar(istream& in) { + if(eof(in)) return -1; - char c = (char)in.peek(); + char c = (char)peek(in); return c; } @@ -92,14 +88,14 @@ const bool isQuote(const value& token) { return token == quoteSymbol; } -const value skipComment(std::istream& in); -const value readQuoted(std::istream& in); -const value readIdentifier(const char chr, std::istream& in); -const value readString(std::istream& in); -const value readNumber(const char chr, std::istream& in); -const value readValue(std::istream& in); +const value skipComment(istream& in); +const value readQuoted(istream& in); +const value readIdentifier(const char chr, istream& in); +const value readString(istream& in); +const value readNumber(const char chr, istream& in); +const value readValue(istream& in); -const value readToken(std::istream& in) { +const value readToken(istream& in) { const char firstChar = readChar(in); if(isWhitespace(firstChar)) return readToken(in); @@ -119,22 +115,22 @@ const value readToken(std::istream& in) { return readNumber(firstChar, in); if(firstChar == -1) return value(); - logStream() << "Illegal lexical syntax '" << firstChar << "'" << std::endl; + logStream() << "Illegal lexical syntax '" << firstChar << "'" << endl; return readToken(in); } -const value skipComment(std::istream& in) { +const value skipComment(istream& in) { const char nextChar = readChar(in); if (nextChar == '\n') return readToken(in); return skipComment(in); } -const value readQuoted(std::istream& in) { +const value readQuoted(istream& in) { return mklist(quoteSymbol, readValue(in)); } -const list<value> readList(const list<value>& listSoFar, std::istream& in) { +const list<value> readList(const list<value>& listSoFar, istream& in) { const value token = readToken(in); if(isNil(token) || isRightParenthesis(token)) return reverse(listSoFar); @@ -143,72 +139,73 @@ const list<value> readList(const list<value>& listSoFar, std::istream& in) { return readList(cons(token, listSoFar), in); } -const std::string listToString(const list<char>& l) { +const string listToString(const list<char>& l) { if(isNil(l)) return ""; - return car(l) + listToString(cdr(l)); + const char buf[1] = { car(l) }; + return string(buf, 1) + listToString(cdr(l)); } -const list<char> readIdentifierHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readIdentifierHelper(const list<char>& listSoFar, istream& in) { const char nextChar = peekChar(in); if(isIdentifierPart(nextChar)) return readIdentifierHelper(cons(readChar(in), listSoFar), in); return reverse(listSoFar); } -const value readIdentifier(const char chr, std::istream& in) { - return listToString(readIdentifierHelper(mklist(chr), in)).c_str(); +const value readIdentifier(const char chr, istream& in) { + return c_str(listToString(readIdentifierHelper(mklist(chr), in))); } -const list<char> readStringHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readStringHelper(const list<char>& listSoFar, istream& in) { const char nextChar = readChar(in); if(nextChar != -1 && nextChar != '"') return readStringHelper(cons(nextChar, listSoFar), in); return reverse(listSoFar); } -const value readString(std::istream& in) { +const value readString(istream& in) { return listToString(readStringHelper(list<char>(), in)); } -const list<char> readNumberHelper(const list<char>& listSoFar, std::istream& in) { +const list<char> readNumberHelper(const list<char>& listSoFar, istream& in) { const char nextChar = peekChar(in); if(isDigit(nextChar)) return readNumberHelper(cons(readChar(in), listSoFar), in); return reverse(listSoFar); } -const value readNumber(const char chr, std::istream& in) { +const value readNumber(const char chr, istream& in) { return stringToNumber(listToString(readNumberHelper(mklist(chr), in))); } -const value readValue(std::istream& in) { +const value readValue(istream& in) { const value nextToken = readToken(in); if(isLeftParenthesis(nextToken)) return readList(list<value> (), in); return nextToken; } -const value readValue(const std::string s) { - std::istringstream in(s); +const value readValue(const string s) { + istringstream in(s); const value nextToken = readToken(in); if(isLeftParenthesis(nextToken)) return readList(list<value> (), in); return nextToken; } -const bool writeValue(const value& val, std::ostream& out) { +const bool writeValue(const value& val, ostream& out) { out << val; return true; } -const std::string writeValue(const value& val) { - std::ostringstream out; +const string writeValue(const value& val) { + ostringstream out; out << val; - return out.str(); + return str(out); } -const value readScript(std::istream& in) { +const value readScript(istream& in) { const value val = readValue(in); if (isNil(val)) return list<value>(); diff --git a/sca-cpp/trunk/modules/eval/primitive.hpp b/sca-cpp/trunk/modules/eval/primitive.hpp index 37c53fdd0b..75d691c4ac 100644 --- a/sca-cpp/trunk/modules/eval/primitive.hpp +++ b/sca-cpp/trunk/modules/eval/primitive.hpp @@ -28,7 +28,7 @@ #include <apr_general.h> #include <apr_uuid.h> -#include <iostream> +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "value.hpp" @@ -40,24 +40,24 @@ const value primitiveSymbol("primitive"); const value quoteSymbol("'"); const value lambdaSymbol("lambda"); -std::ostream* displayOutStream = &std::cout; -std::ostream* logOutStream = &std::cerr; +ostream* displayOutStream = &cout; +ostream* logOutStream = &cerr; -const bool setupDisplay(std::ostream& out) { +const bool setupDisplay(ostream& out) { displayOutStream = &out; return true; } -std::ostream& displayStream() { +ostream& displayStream() { return *displayOutStream; } -const bool setupLog(std::ostream& out) { +const bool setupLog(ostream& out) { logOutStream = &out; return true; } -std::ostream& logStream() { +ostream& logStream() { return *logOutStream; } @@ -116,7 +116,7 @@ const value divProc(const list<value>& args) { const value displayProc(const list<value>& args) { if (isNil(args)) { - displayStream() << std::endl; + displayStream() << endl; return true; } displayStream() << car(args); @@ -125,7 +125,7 @@ const value displayProc(const list<value>& args) { const value logProc(const list<value>& args) { if (isNil(args)) { - logStream() << std::endl; + logStream() << endl; return true; } logStream() << car(args); @@ -137,7 +137,7 @@ const value uuidProc(unused const list<value>& args) { apr_uuid_get(&uuid); char buf[APR_UUID_FORMATTED_LENGTH]; apr_uuid_format(buf, &uuid); - return std::string(buf, APR_UUID_FORMATTED_LENGTH); + return string(buf, APR_UUID_FORMATTED_LENGTH); } const value cadrProc(unused const list<value>& args) { @@ -194,51 +194,49 @@ template<typename F> const value primitiveProcedure(const F& f) { } const list<value> primitiveProcedureNames() { - list<value> l = mklist<value>("car"); - l = cons<value>("cdr", l); - l = cons<value>("cons", l); - l = cons<value>("list", l); - l = cons<value>("nul", l); - l = cons<value>("=", l); - l = cons<value>("equal?", l); - l = cons<value>("+", l); - l = cons<value>("-", l); - l = cons<value>("*", l); - l = cons<value>("/", l); - l = cons<value>("assoc", l); - l = cons<value>("cadr", l); - l = cons<value>("caddr", l); - l = cons<value>("cadddr", l); - l = cons<value>("cddr", l); - l = cons<value>("cdddr", l); - l = cons<value>("display", l); - l = cons<value>("log", l); - l = cons<value>("uuid", l); - return l; + return mklist<value>("car") + + "cdr" + + "cons" + + "list" + + "nul" + + "=" + + "equal?" + + "+" + + "-" + + "*" + + "/" + + "assoc" + + "cadr" + + "caddr" + + "cadddr" + + "cddr" + + "cdddr" + + "display" + + "log" + + "uuid"; } const list<value> primitiveProcedureObjects() { - list<value> l = mklist(primitiveProcedure(carProc)); - l = cons(primitiveProcedure(cdrProc), l); - l = cons(primitiveProcedure(consProc), l); - l = cons(primitiveProcedure(listProc), l); - l = cons(primitiveProcedure(nulProc), l); - l = cons(primitiveProcedure(equalProc), l); - l = cons(primitiveProcedure(equalProc), l); - l = cons(primitiveProcedure(addProc), l); - l = cons(primitiveProcedure(subProc), l); - l = cons(primitiveProcedure(mulProc), l); - l = cons(primitiveProcedure(divProc), l); - l = cons(primitiveProcedure(assocProc), l); - l = cons(primitiveProcedure(cadrProc), l); - l = cons(primitiveProcedure(caddrProc), l); - l = cons(primitiveProcedure(cadddrProc), l); - l = cons(primitiveProcedure(cddrProc), l); - l = cons(primitiveProcedure(cdddrProc), l); - l = cons(primitiveProcedure(displayProc), l); - l = cons(primitiveProcedure(logProc), l); - l = cons(primitiveProcedure(uuidProc), l); - return l; + return mklist(primitiveProcedure(carProc)) + + primitiveProcedure(cdrProc) + + primitiveProcedure(consProc) + + primitiveProcedure(listProc) + + primitiveProcedure(nulProc) + + primitiveProcedure(equalProc) + + primitiveProcedure(equalProc) + + primitiveProcedure(addProc) + + primitiveProcedure(subProc) + + primitiveProcedure(mulProc) + + primitiveProcedure(divProc) + + primitiveProcedure(assocProc) + + primitiveProcedure(cadrProc) + + primitiveProcedure(caddrProc) + + primitiveProcedure(cadddrProc) + + primitiveProcedure(cddrProc) + + primitiveProcedure(cdddrProc) + + primitiveProcedure(displayProc) + + primitiveProcedure(logProc) + + primitiveProcedure(uuidProc); } const bool isFalse(const value& exp) { diff --git a/sca-cpp/trunk/modules/http/curl-test.cpp b/sca-cpp/trunk/modules/http/curl-test.cpp index 01355dd429..4305d2ac38 100644 --- a/sca-cpp/trunk/modules/http/curl-test.cpp +++ b/sca-cpp/trunk/modules/http/curl-test.cpp @@ -24,21 +24,15 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "perf.hpp" #include "curl.hpp" namespace tuscany { namespace http { -const bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { +ostream* curlWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -46,16 +40,16 @@ std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { const bool testGet() { CURLSession ch; { - std::ostringstream os; - const failable<list<std::ostringstream*>, std::string> r = get<std::ostringstream*>(curlWriter, &os, "http://localhost:8090", ch); + ostringstream os; + const failable<list<ostream*> > r = get<ostream*>(curlWriter, &os, "http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(os.str(), "HTTP/1.1 200 OK")); - assert(contains(os.str(), "It works")); + assert(contains(str(os), "HTTP/1.1 200 OK")); + assert(contains(str(os), "It works")); } { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); } return true; } @@ -65,9 +59,9 @@ struct getLoop { getLoop(CURLSession& ch) : ch(ch) { } const bool operator()() const { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); return true; } }; @@ -75,7 +69,7 @@ struct getLoop { const bool testGetPerf() { CURLSession ch; lambda<bool()> gl = getLoop(ch); - std::cout << "Static GET test " << time(gl, 5, 200) << " ms" << std::endl; + cout << "Static GET test " << time(gl, 5, 200) << " ms" << endl; return true; } @@ -83,12 +77,12 @@ const bool testGetPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::http::testGet(); tuscany::http::testGetPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/http/curl.hpp b/sca-cpp/trunk/modules/http/curl.hpp index 85665c2785..3478a590fd 100644 --- a/sca-cpp/trunk/modules/http/curl.hpp +++ b/sca-cpp/trunk/modules/http/curl.hpp @@ -29,7 +29,7 @@ #include <curl/curl.h> #include <curl/types.h> #include <curl/easy.h> -#include <string> +#include "string.hpp" #include "gc.hpp" #include "list.hpp" #include "value.hpp" @@ -62,7 +62,7 @@ CURLContext curlContext; */ class CURLSession { public: - CURLSession() : ch(new CURLHandle()) { + CURLSession() : ch(new (gc_new<CURLHandle>()) CURLHandle()) { } ~CURLSession() { @@ -103,9 +103,9 @@ CURL* handle(const CURLSession& c) { */ class CURLReadContext { public: - CURLReadContext(const list<std::string>& ilist) : ilist(ilist) { + CURLReadContext(const list<string>& ilist) : ilist(ilist) { } - list<std::string> ilist; + list<string> ilist; }; /** @@ -115,11 +115,11 @@ size_t readCallback(void *ptr, size_t size, size_t nmemb, void *data) { CURLReadContext& rcx = *static_cast<CURLReadContext*>(data); if (isNil(rcx.ilist)) return 0; - rcx.ilist = fragment(rcx.ilist, size * nmemb); - const std::string s = car(rcx.ilist); - rcx.ilist = cdr(rcx.ilist); - s.copy((char*)ptr, s.length()); - return s.length(); + const list<string> f(fragment(rcx.ilist, size * nmemb)); + const string s = car(f); + rcx.ilist = cdr(f); + memcpy(ptr, c_str(s), length(s)); + return length(s); } /** @@ -127,9 +127,9 @@ size_t readCallback(void *ptr, size_t size, size_t nmemb, void *data) { */ template<typename R> class CURLWriteContext { public: - CURLWriteContext(const lambda<R(const std::string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { + CURLWriteContext(const lambda<R(const string&, const R)>& reduce, const R& accum) : reduce(reduce), accum(accum) { } - const lambda<R(const std::string&, const R)> reduce; + const lambda<R(const string&, const R)> reduce; R accum; }; @@ -137,33 +137,23 @@ public: * Called by CURL to write received data. */ template<typename R> size_t writeCallback(void *ptr, size_t size, size_t nmemb, void *data) { - CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); - const size_t realsize = size * nmemb; - wcx.accum = wcx.reduce(std::string((const char*)ptr, realsize), wcx.accum); - return realsize; -} - -/** - * Called by CURL to write received header data. - */ -template<typename R> size_t headerCallback(void *ptr, size_t size, size_t nmemb, void *data) { - CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); - const size_t realsize = size * nmemb; - wcx.accum = wcx.reduce(std::string((const char*)ptr, realsize), wcx.accum); - return realsize; + CURLWriteContext<R>& wcx = *(static_cast<CURLWriteContext<R>*> (data)); + const size_t realsize = size * nmemb; + wcx.accum = wcx.reduce(string((const char*)ptr, realsize), wcx.accum); + return realsize; } /** * Apply an HTTP verb to a list containing a list of headers and a list of content, and * a reduce function used to process the response. */ -curl_slist* headers(curl_slist* cl, const list<std::string>& h) { +curl_slist* headers(curl_slist* cl, const list<string>& h) { if (isNil(h)) return cl; - return headers(curl_slist_append(cl, std::string(car(h)).c_str()), cdr(h)); + return headers(curl_slist_append(cl, c_str(string(car(h)))), cdr(h)); } -template<typename R> const failable<list<R>, std::string> apply(const list<list<std::string> >& req, const lambda<R(const std::string&, const R)>& reduce, const R& initial, const std::string& url, const std::string& verb, const CURLSession& cs) { +template<typename R> const failable<list<R> > apply(const list<list<string> >& hdr, const lambda<R(const string&, const R)>& reduce, const R& initial, const string& url, const string& verb, const CURLSession& cs) { // Init the curl session CURL* ch = handle(cs); @@ -171,30 +161,30 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< curl_easy_setopt(ch, CURLOPT_USERAGENT, "libcurl/1.0"); //TODO use HTTP chunking, for now just convert request to a single string - std::ostringstream os; - write(cadr(req), os); - const std::string s = os.str(); - const int sz = s.length(); + ostringstream os; + write(cadr(hdr), os); + const string s = str(os); + const int sz = length(s); // Setup the read, header and write callbacks CURLReadContext rcx(mklist(s)); curl_easy_setopt(ch, CURLOPT_READFUNCTION, (size_t (*)(void*, size_t, size_t, void*))readCallback); curl_easy_setopt(ch, CURLOPT_READDATA, &rcx); CURLWriteContext<R> hcx(reduce, initial); - curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, (size_t (*)(void*, size_t, size_t, void*))headerCallback<R>); + curl_easy_setopt(ch, CURLOPT_HEADERFUNCTION, (size_t (*)(void*, size_t, size_t, void*))(writeCallback<R>)); curl_easy_setopt(ch, CURLOPT_HEADERDATA, &hcx); CURLWriteContext<R> wcx(reduce, initial); - curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, (size_t (*)(void*, size_t, size_t, void*))writeCallback<R>); + curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, (size_t (*)(void*, size_t, size_t, void*))(writeCallback<R>)); curl_easy_setopt(ch, CURLOPT_WRITEDATA, &wcx); curl_easy_setopt(ch, CURLOPT_TCP_NODELAY, true); // Set the request headers - curl_slist* hl = headers(NULL, car(req)); + curl_slist* hl = headers(NULL, car(hdr)); if (hl != NULL) curl_easy_setopt(ch, CURLOPT_HTTPHEADER, hl); // Apply the HTTP verb - curl_easy_setopt(ch, CURLOPT_URL, url.c_str()); + curl_easy_setopt(ch, CURLOPT_URL, c_str(url)); if (verb == "POST") { curl_easy_setopt(ch, CURLOPT_POST, true); curl_easy_setopt(ch, CURLOPT_POSTFIELDSIZE, sz); @@ -210,13 +200,13 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< // Return the HTTP return code or content if (rc) - return mkfailure<list<R>, std::string>(curl_easy_strerror(rc)); + return mkfailure<list<R> >(string(curl_easy_strerror(rc))); long httprc; curl_easy_getinfo (ch, CURLINFO_RESPONSE_CODE, &httprc); if (httprc != 200 && httprc != 201) { - std::ostringstream es; + ostringstream es; es << "HTTP code " << httprc; - return mkfailure<list<R>, std::string>(es.str()); + return mkfailure<list<R> >(str(es)); } return mklist<R>(hcx.accum, wcx.accum); } @@ -224,26 +214,26 @@ template<typename R> const failable<list<R>, std::string> apply(const list<list< /** * Evaluate an expression remotely, at the given URL. */ -const failable<value, std::string> evalExpr(const value& expr, const std::string& url, const CURLSession& ch) { +const failable<value> evalExpr(const value& expr, const string& url, const CURLSession& ch) { debug(url, "http::evalExpr::url"); debug(expr, "http::evalExpr::input"); // Convert expression to a JSON-RPC request json::JSONContext cx; - const failable<list<std::string>, std::string> jsreq = jsonRequest(1, car<value>(expr), cdr<value>(expr), cx); + const failable<list<string> > jsreq = json::jsonRequest(1, car<value>(expr), cdr<value>(expr), cx); if (!hasContent(jsreq)) - return mkfailure<value, std::string>(reason(jsreq)); + return mkfailure<value>(reason(jsreq)); // POST it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/json-rpc"); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(mklist<list<std::string> >(h, content(jsreq)), rcons<std::string>, list<std::string>(), url, "POST", ch); + const list<string> h = mklist<string>("Content-Type: application/json-rpc"); + const failable<list<list<string> > > res = apply<list<string> >(mklist<list<string> >(h, content(jsreq)), rcons<string>, list<string>(), url, "POST", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); // Return result - failable<list<value>, std::string> jsres = json::readJSON(cadr<list<std::string> >(content(res)), cx); + failable<list<value> > jsres = json::readJSON(cadr<list<string> >(content(res)), cx); if (!hasContent(jsres)) - return mkfailure<value, std::string>(reason(jsres)); + return mkfailure<value>(reason(jsres)); const list<value> val = elementsToValues(content(jsres)); const value rval(cadr<value>(cadr<value>(val))); @@ -254,72 +244,88 @@ const failable<value, std::string> evalExpr(const value& expr, const std::string /** * Find and return a header. */ -const failable<std::string, std::string> header(const std::string& prefix, const list<std::string>& h) { +const failable<string> header(const char* prefix, const list<string>& h) { if (isNil(h)) - return mkfailure<std::string, std::string>(std::string("Couldn't find header: ") + prefix); - const std::string s = car(h); - if (s.find(prefix) != 0) + return mkfailure<string>(string("Couldn't find header: ") + prefix); + const string s = car(h); + if (find(s, prefix) != 0) return header(prefix, cdr(h)); - const std::string l(s.substr(prefix.length())); - return l.substr(0, l.find_first_of("\r\n")); + const string l(substr(s, length(prefix))); + return substr(l, 0, find_first_of(l, "\r\n")); } /** * Find and return a location header. */ -const failable<std::string, std::string> location(const list<std::string>& h) { +const failable<string> location(const list<string>& h) { return header("Location: ", h); } /** * Convert a location to an entry id. */ -const failable<value, std::string> entryId(const failable<std::string, std::string> l) { +const failable<value> entryId(const failable<string> l) { if (!hasContent(l)) - return mkfailure<value, std::string>(reason(l)); - const std::string ls(content(l)); - return value(ls.substr(ls.find_last_of("/") + 1)); + return mkfailure<value>(reason(l)); + const string ls(content(l)); + return value(string(substr(ls, find_last(ls, '/') + 1))); } /** * Find and return a content-type header. */ -const failable<std::string, std::string> contentType(const list<std::string>& h) { +const failable<string> contentType(const list<string>& h) { return header("Content-Type: ", h); } /** * HTTP GET, return the resource at the given URL. */ -template<typename R> const failable<list<R>, std::string> get(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const std::string& url, const CURLSession& ch) { +template<typename R> const failable<list<R> > get(const lambda<R(const string&, const R)>& reduce, const R& initial, const string& url, const CURLSession& ch) { debug(url, "http::get::url"); - const list<list<std::string> > req = mklist(list<std::string>(), list<std::string>()); + const list<list<string> > req = mklist(list<string>(), list<string>()); return apply(req, reduce, initial, url, "GET", ch); } /** * HTTP GET, return a list of values representing the resource at the given URL. */ -const failable<value, std::string> get(const std::string& url, const CURLSession& ch) { +const failable<value> getcontent(const string& url, const CURLSession& ch) { + debug(url, "http::get::url"); + + // Get the contents of the resource at the given URL + const failable<list<list<string> > > res = get<list<string>>(rcons<string>, list<string>(), url, ch); + if (!hasContent(res)) + return mkfailure<value>(reason(res)); + const list<string> ls(reverse(cadr(content(res)))); + + // Return the content as a list of values + const value val(mkvalues(ls)); + debug(val, "http::get::result"); + return val; +} + +/** + * HTTP GET, return a list of values representing the resource at the given URL. + */ +const failable<value> get(const string& url, const CURLSession& ch) { debug(url, "http::get::url"); // Get the contents of the resource at the given URL - const failable<list<list<std::string> >, std::string> res = get<list<std::string> >(rcons<std::string>, list<std::string>(), url, ch); + const failable<list<list<string> > > res = get<list<string> >(rcons<string>, list<string>(), url, ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); - const list<std::string> ls(reverse(cadr(content(res)))); + return mkfailure<value>(reason(res)); + const list<string> ls(reverse(cadr(content(res)))); - const std::string ct(content(contentType(car(content(res))))); + const string ct(content(contentType(car(content(res))))); if (ct == "application/atom+xml;type=entry") { const value val(atom::entryValue(content(atom::readEntry(ls)))); debug(val, "http::get::result"); return val; } - // Return the content as a string value - std::ostringstream os; - write(ls, os); - const value val(os.str()); + // Return the content as a list of values + const value val(mkvalues(ls)); debug(val, "http::get::result"); return val; } @@ -327,24 +333,24 @@ const failable<value, std::string> get(const std::string& url, const CURLSession /** * HTTP POST. */ -const failable<value, std::string> post(const value& val, const std::string& url, const CURLSession& ch) { +const failable<value> post(const value& val, const string& url, const CURLSession& ch) { // Convert value to an ATOM entry - const failable<list<std::string>, std::string> entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); + const failable<list<string> > entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); if (!hasContent(entry)) - return mkfailure<value, std::string>(reason(entry)); + return mkfailure<value>(reason(entry)); debug(url, "http::post::url"); debug(content(entry), "http::post::input"); // POST it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/atom+xml"); - const list<list<std::string> > req = mklist<list<std::string> >(h, content(entry)); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "POST", ch); + const list<string> h = mklist<string>("Content-Type: application/atom+xml"); + const list<list<string> > req = mklist<list<string> >(h, content(entry)); + const failable<list<list<string> > > res = apply<list<string>>(req, rcons<string>, list<string>(), url, "POST", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); // Return the new entry id from the HTTP location header - const failable<value, std::string> eid(entryId(location(car(content(res))))); + const failable<value> eid(entryId(location(car(content(res))))); debug(eid, "http::post::result"); return eid; } @@ -352,21 +358,21 @@ const failable<value, std::string> post(const value& val, const std::string& url /** * HTTP PUT. */ -const failable<value, std::string> put(const value& val, const std::string& url, const CURLSession& ch) { +const failable<value> put(const value& val, const string& url, const CURLSession& ch) { // Convert value to an ATOM entry - const failable<list<std::string>, std::string> entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); + const failable<list<string> > entry = atom::writeATOMEntry(atom::entryValuesToElements(val)); if (!hasContent(entry)) - return mkfailure<value, std::string>(reason(entry)); + return mkfailure<value>(reason(entry)); debug(url, "http::put::url"); debug(content(entry), "http::put::input"); // PUT it to the URL - const list<std::string> h = mklist<std::string>("Content-Type: application/atom+xml"); - const list<list<std::string> > req = mklist<list<std::string> >(h, content(entry)); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "PUT", ch); + const list<string> h = mklist<string>("Content-Type: application/atom+xml"); + const list<list<string> > req = mklist<list<string> >(h, content(entry)); + const failable<list<list<string> > > res = apply<list<string> >(req, rcons<string>, list<string>(), url, "PUT", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); debug(true, "http::put::result"); return value(true); @@ -375,13 +381,13 @@ const failable<value, std::string> put(const value& val, const std::string& url, /** * HTTP DELETE. */ -const failable<value, std::string> del(const std::string& url, const CURLSession& ch) { +const failable<value, string> del(const string& url, const CURLSession& ch) { debug(url, "http::delete::url"); - const list<list<std::string> > req = mklist(list<std::string>(), list<std::string>()); - const failable<list<list<std::string> >, std::string> res = apply<list<std::string> >(req, rcons<std::string>, list<std::string>(), url, "DELETE", ch); + const list<list<string> > req = mklist(list<string>(), list<string>()); + const failable<list<list<string> > > res = apply<list<string> >(req, rcons<string>, list<string>(), url, "DELETE", ch); if (!hasContent(res)) - return mkfailure<value, std::string>(reason(res)); + return mkfailure<value>(reason(res)); debug(true, "http::delete::result"); return value(true); @@ -391,18 +397,18 @@ const failable<value, std::string> del(const std::string& url, const CURLSession * HTTP client proxy function. */ struct proxy { - proxy(const std::string& url) : url(url) { + proxy(const string& url) : url(url) { } const value operator()(const list<value>& args) const { CURLSession cs; - failable<value, std::string> val = evalExpr(args, url, cs); + failable<value> val = evalExpr(args, url, cs); if (!hasContent(val)) return value(); return content(val); } - const std::string url; + const string url; }; } diff --git a/sca-cpp/trunk/modules/http/httpd.hpp b/sca-cpp/trunk/modules/http/httpd.hpp index 890fee8f01..e0c5d110c4 100644 --- a/sca-cpp/trunk/modules/http/httpd.hpp +++ b/sca-cpp/trunk/modules/http/httpd.hpp @@ -26,8 +26,8 @@ * HTTPD module implementation functions. */ -#include <string> -#include <iostream> +#include "string.hpp" +#include "stream.hpp" #include "apr_strings.h" #include "apr_fnmatch.h" @@ -60,9 +60,7 @@ namespace httpd { * Returns a server-scoped module configuration. */ template<typename C> void* makeServerConf(apr_pool_t *p, server_rec *s) { - C* c = new (apr_palloc(p, sizeof(C))) C(s); - apr_pool_cleanup_register(p, c, gc_pool_cleanupCallback<C>, apr_pool_cleanup_null) ; - return c; + return new (gc_new<C>(p)) C(s); } template<typename C> const C& serverConf(const request_rec* r, const module* mod) { @@ -78,9 +76,7 @@ template<typename C> C& serverConf(const cmd_parms *cmd, const module* mod) { * Returns a directory-scoped module configuration. */ template<typename C> void *makeDirConf(apr_pool_t *p, char *dirspec) { - C* c = new (apr_palloc(p, sizeof(C))) C(dirspec); - apr_pool_cleanup_register(p, c, gc_pool_cleanupCallback<C>, apr_pool_cleanup_null) ; - return c; + return new (gc_new<C>(p)) C(dirspec); } template<typename C> C& dirConf(const request_rec* r, const module* mod) { @@ -90,31 +86,25 @@ template<typename C> C& dirConf(const request_rec* r, const module* mod) { /** * Convert a path string to a list of values. */ -const list<std::string> pathTokens(const char* p) { +const list<string> pathTokens(const char* p) { if (p == NULL || p[0] == '\0') - return list<std::string>(); + return list<string>(); if (p[0] == '/') return tokenize("/", p + 1); return tokenize("/", p); } -const list<value> pathValues(const list<std::string>& l) { - if (isNil(l)) - return list<value>(); - return cons<value>(car(l), pathValues(cdr(l))); -} - -const list<value> path(const char* p) { - return pathValues(pathTokens(p)); +const list<value> pathValues(const char* p) { + return mkvalues(pathTokens(p)); } /** * Convert a path represented as a list of values to a string. */ -const std::string path(const list<value>& p) { +const string path(const list<value>& p) { if (isNil(p)) return ""; - return std::string("/") + std::string(car(p)) + path(cdr(p)); + return string("/") + car(p) + path(cdr(p)); } /** @@ -126,7 +116,7 @@ const char* optional(const char* s) { return s; } -const std::string contentType(const request_rec* r) { +const string contentType(const request_rec* r) { return optional(apr_table_get(r->headers_in, "Content-Type")); } @@ -136,24 +126,24 @@ const std::string contentType(const request_rec* r) { * Debug log. */ int debugHeader(unused void* r, const char* key, const char* value) { - std::cerr << " header key: " << key << ", value: " << value << std::endl; + cerr << " header key: " << key << ", value: " << value << endl; return 1; } -const bool debugRequest(request_rec* r, const std::string& msg) { - std::cerr << msg << ":" << std::endl; - std::cerr << " protocol: " << optional(r->protocol) << std::endl; - std::cerr << " method: " << optional(r->method) << std::endl; - std::cerr << " method number: " << r->method_number << std::endl; - std::cerr << " content type: " << contentType(r) << std::endl; - std::cerr << " content encoding: " << optional(r->content_encoding) << std::endl; +const bool debugRequest(request_rec* r, const string& msg) { + cerr << msg << ":" << endl; + cerr << " protocol: " << optional(r->protocol) << endl; + cerr << " method: " << optional(r->method) << endl; + cerr << " method number: " << r->method_number << endl; + cerr << " content type: " << contentType(r) << endl; + cerr << " content encoding: " << optional(r->content_encoding) << endl; apr_table_do(debugHeader, r, r->headers_in, NULL); - std::cerr << " unparsed uri: " << optional(r->unparsed_uri) << std::endl; - std::cerr << " uri: " << optional(r->uri) << std::endl; - std::cerr << " path info: " << optional(r->path_info) << std::endl; - std::cerr << " filename: " << optional(r->filename) << std::endl; - std::cerr << " uri tokens: " << pathTokens(r->uri) << std::endl; - std::cerr << " args: " << optional(r->args) << std::endl; + cerr << " unparsed uri: " << optional(r->unparsed_uri) << endl; + cerr << " uri: " << optional(r->uri) << endl; + cerr << " path info: " << optional(r->path_info) << endl; + cerr << " filename: " << optional(r->filename) << endl; + cerr << " uri tokens: " << pathTokens(r->uri) << endl; + cerr << " args: " << optional(r->args) << endl; return true; } @@ -177,16 +167,16 @@ const list<value> pathInfo(const list<value>& uri, const list<value>& path) { /** * Returns a list of key value pairs from the args in a query string. */ -const list<value> queryArg(const std::string& s) { - const list<std::string> t = tokenize("=", s); - return mklist<value>(car(t).c_str(), cadr(t)); +const list<value> queryArg(const string& s) { + const list<string> t = tokenize("=", s); + return mklist<value>(c_str(car(t)), cadr(t)); } const list<list<value> > queryArgs(const request_rec* r) { const char* a = r->args; if (a == NULL) return list<list<value> >(); - return map<std::string, list<value>>(queryArg, tokenize("&", a)); + return map<string, list<value>>(queryArg, tokenize("&", a)); } /** @@ -229,50 +219,49 @@ const int setupReadPolicy(request_rec* r) { /** * Read the content of a POST or PUT. */ -const list<std::string> read(request_rec* r) { - char b[2048]; - const int n = ap_get_client_block(r, b, 2048); +const list<string> read(request_rec* r) { + char b[1024]; + const int n = ap_get_client_block(r, b, sizeof(b)); if (n <= 0) - return list<std::string>(); - return cons(std::string(b, n), read(r)); + return list<string>(); + return cons(string(b, n), read(r)); } /** * Convert a URI value to an absolute URL. */ const char* url(const value& v, request_rec* r) { - std::string u = r->uri; - u.append("/"); - u.append(v); - return ap_construct_url(r->pool, u.c_str(), r); + const string u = string(r->uri) + "/" + v; + return ap_construct_url(r->pool, c_str(u), r); } /** * Write an HTTP result. */ -const failable<int, std::string> writeResult(const failable<list<std::string>, std::string>& ls, const std::string& ct, request_rec* r) { +const failable<int> writeResult(const failable<list<string> >& ls, const string& ct, request_rec* r) { if (!hasContent(ls)) - return mkfailure<int, std::string>(reason(ls)); - std::ostringstream os; + return mkfailure<int>(reason(ls)); + ostringstream os; write(content(ls), os); - debug(os.str(), "httpd::result"); + const string ob(str(os)); + debug(ob, "httpd::result"); - const std::string etag(ap_md5(r->pool, (const unsigned char*)std::string(os.str()).c_str())); + const string etag(ap_md5(r->pool, (const unsigned char*)c_str(ob))); const char* match = apr_table_get(r->headers_in, "If-None-Match"); - apr_table_setn(r->headers_out, "ETag", apr_pstrdup(r->pool, etag.c_str())); + apr_table_setn(r->headers_out, "ETag", apr_pstrdup(r->pool, c_str(etag))); if (match != NULL && etag == match) { r->status = HTTP_NOT_MODIFIED; return OK; } - ap_set_content_type(r, apr_pstrdup(r->pool, ct.c_str())); - ap_rputs(std::string(os.str()).c_str(), r); + ap_set_content_type(r, apr_pstrdup(r->pool, c_str(ct))); + ap_rputs(c_str(ob), r); return OK; } /** * Report request execution status. */ -const int reportStatus(const failable<int, std::string>& rc) { +const int reportStatus(const failable<int>& rc) { if (!hasContent(rc)) return HTTP_INTERNAL_SERVER_ERROR; return content(rc); diff --git a/sca-cpp/trunk/modules/json/json-test.cpp b/sca-cpp/trunk/modules/json/json-test.cpp index 4d1bbffd5a..b4a6ba8746 100644 --- a/sca-cpp/trunk/modules/json/json-test.cpp +++ b/sca-cpp/trunk/modules/json/json-test.cpp @@ -24,10 +24,8 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "json.hpp" namespace tuscany { @@ -35,15 +33,15 @@ namespace json { bool testJSEval() { JSONContext cx; - const std::string script("(function testJSON(n){ return JSON.parse(JSON.stringify(n)) })(5)"); + const string script("(function testJSON(n){ return JSON.parse(JSON.stringify(n)) })(5)"); jsval rval; - assert(JS_EvaluateScript(cx, cx.getGlobal(), script.c_str(), script.length(), "testJSON.js", 1, &rval)); - const std::string r(JS_GetStringBytes(JS_ValueToString(cx, rval))); + assert(JS_EvaluateScript(cx, cx.getGlobal(), c_str(script), length(script), "testJSON.js", 1, &rval)); + const string r(JS_GetStringBytes(JS_ValueToString(cx, rval))); assert(r == "5"); return true; } -std::ostringstream* jsonWriter(const std::string& s, std::ostringstream* os) { +ostream* jsonWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -52,30 +50,30 @@ bool testJSON() { const JSONContext cx; { - const list<value> ad = mklist<value>(mklist<value>(attribute, "city", std::string("san francisco")), mklist<value>(attribute, "state", std::string("ca"))); - const list<value> ac = mklist<value>(mklist<value>(element, "id", std::string("1234")), mklist<value>(attribute, "balance", 1000)); - const list<value> cr = mklist<value>(mklist<value> (attribute, "name", std::string("jdoe")), cons<value>(element, cons<value>("address", ad)), cons<value>(element, cons<value>("account", ac))); + const list<value> ad = mklist<value>(mklist<value>(attribute, "city", string("san francisco")), mklist<value>(attribute, "state", string("ca"))); + const list<value> ac = mklist<value>(mklist<value>(element, "id", string("1234")), mklist<value>(attribute, "balance", 1000)); + const list<value> cr = mklist<value>(mklist<value> (attribute, "name", string("jdoe")), cons<value>(element, cons<value>("address", ad)), cons<value>(element, cons<value>("account", ac))); const list<value> c = mklist<value>(cons<value>(element, cons<value>("customer", cr))); - std::ostringstream os; - writeJSON<std::ostringstream*>(jsonWriter, &os, c, cx); - assert(os.str() == "{\"customer\":{\"name\":\"jdoe\",\"address\":{\"city\":\"san francisco\",\"state\":\"ca\"},\"account\":{\"id\":\"1234\",\"balance\":1000}}}"); + ostringstream os; + writeJSON<ostream*>(jsonWriter, &os, c, cx); + assert(str(os) == "{\"customer\":{\"name\":\"jdoe\",\"address\":{\"city\":\"san francisco\",\"state\":\"ca\"},\"account\":{\"id\":\"1234\",\"balance\":1000}}}"); } { - const list<value> phones = mklist<value> (std::string("408-1234"), std::string("650-1234")); - const list<value> l = mklist<value> (mklist<value> (element, "phones", phones), mklist<value> (element, "lastName", std::string("test\ttab")), mklist<value> (element, "firstName", std::string("test1"))); + const list<value> phones = mklist<value> (string("408-1234"), string("650-1234")); + const list<value> l = mklist<value> (mklist<value> (element, "phones", phones), mklist<value> (element, "lastName", string("test\ttab")), mklist<value> (element, "firstName", string("test1"))); - std::ostringstream os; - writeJSON<std::ostringstream*>(jsonWriter, &os, l, cx); - assert(os.str() == "{\"phones\":[\"408-1234\",\"650-1234\"],\"lastName\":\"test\\u0009tab\",\"firstName\":\"test1\"}"); + ostringstream os; + writeJSON<ostream*>(jsonWriter, &os, l, cx); + assert(str(os) == "{\"phones\":[\"408-1234\",\"650-1234\"],\"lastName\":\"test\\u0009tab\",\"firstName\":\"test1\"}"); - std::istringstream is(os.str()); - const list<std::string> il = streamList(is); + istringstream is(str(os)); + const list<string> il = streamList(is); const list<value> r = content(readJSON(il, cx)); assert(r == l); - std::ostringstream wos; + ostringstream wos; write(content(writeJSON(r, cx)), wos); - assert(wos.str() == os.str()); + assert(str(wos) == str(os)); } return true; } @@ -83,45 +81,45 @@ bool testJSON() { bool testJSONRPC() { JSONContext cx; { - const std::string lm("{\"id\": 1, \"method\": \"system.listMethods\", \"params\": []}"); + const string lm("{\"id\": 1, \"method\": \"system.listMethods\", \"params\": []}"); const list<value> e = content(readJSON(mklist(lm), cx)); const list<value> v = elementsToValues(e); assert(assoc<value>("id", v) == mklist<value>("id", 1)); - assert(assoc<value>("method", v) == mklist<value>("method", std::string("system.listMethods"))); + assert(assoc<value>("method", v) == mklist<value>("method", string("system.listMethods"))); assert(assoc<value>("params", v) == mklist<value>("params", list<value>())); } { - const std::string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); + const string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); const list<value> e = content(readJSON(mklist(i), cx)); - const std::string i2("{\"id\":3,\"result\":{\"0\":{\"price\":\"$2.99\",\"name\":\"Apple\"},\"1\":{\"price\":\"$3.55\",\"name\":\"Orange\"},\"2\":{\"price\":\"$1.55\",\"name\":\"Pear\"}}}"); + const string i2("{\"id\":3,\"result\":{\"0\":{\"price\":\"$2.99\",\"name\":\"Apple\"},\"1\":{\"price\":\"$3.55\",\"name\":\"Orange\"},\"2\":{\"price\":\"$1.55\",\"name\":\"Pear\"}}}"); const list<value> e2 = content(readJSON(mklist(i), cx)); assert(e == e2); } { - const std::string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); + const string i("{\"id\":3,\"result\":[{\"price\":\"$2.99\",\"name\":\"Apple\"},{\"price\":\"$3.55\",\"name\":\"Orange\"},{\"price\":\"$1.55\",\"name\":\"Pear\"}]}"); const list<value> e = content(readJSON(mklist(i), cx)); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == i); + assert(str(os) == i); const list<value> v = elementsToValues(e); const list<value> r = valuesToElements(v); assert(r == e); } { - const list<value> r = mklist<value>(mklist<value>("id", 1), mklist<value>("result", mklist<value>(std::string("Service.get"), std::string("Service.getTotal")))); + const list<value> r = mklist<value>(mklist<value>("id", 1), mklist<value>("result", mklist<value>(string("Service.get"), string("Service.getTotal")))); const list<value> e = valuesToElements(r); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == "{\"id\":1,\"result\":[\"Service.get\",\"Service.getTotal\"]}"); + assert(str(os) == "{\"id\":1,\"result\":[\"Service.get\",\"Service.getTotal\"]}"); } { - const std::string f("{\"id\":1,\"result\":[\"Sample Feed\",\"123456789\",[\"Item\",\"111\",{\"javaClass\":\"services.Item\",\"name\":\"Apple\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":2.99}],[\"Item\",\"222\",{\"javaClass\":\"services.Item\",\"name\":\"Orange\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":3.55}],[\"Item\",\"333\",{\"javaClass\":\"services.Item\",\"name\":\"Pear\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":1.55}]]}"); + const string f("{\"id\":1,\"result\":[\"Sample Feed\",\"123456789\",[\"Item\",\"111\",{\"javaClass\":\"services.Item\",\"name\":\"Apple\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":2.99}],[\"Item\",\"222\",{\"javaClass\":\"services.Item\",\"name\":\"Orange\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":3.55}],[\"Item\",\"333\",{\"javaClass\":\"services.Item\",\"name\":\"Pear\",\"currencyCode\":\"USD\",\"currencySymbol\":\"$\",\"price\":1.55}]]}"); const list<value> r = content(readJSON(mklist(f), cx)); const list<value> v = elementsToValues(r); const list<value> e = valuesToElements(v); - std::ostringstream os; + ostringstream os; write(content(writeJSON(e, cx)), os); - assert(os.str() == f); + assert(str(os) == f); } return true; } @@ -130,13 +128,13 @@ bool testJSONRPC() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::json::testJSEval(); tuscany::json::testJSON(); tuscany::json::testJSONRPC(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/json/json.hpp b/sca-cpp/trunk/modules/json/json.hpp index 6ce4e3a9a1..9124c5143c 100644 --- a/sca-cpp/trunk/modules/json/json.hpp +++ b/sca-cpp/trunk/modules/json/json.hpp @@ -28,7 +28,7 @@ #define XP_UNIX #include <jsapi.h> -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "element.hpp" @@ -41,8 +41,8 @@ namespace json { * Report JSON errors. */ void reportError(unused JSContext *cx, const char *message, JSErrorReport *report) { - std::cerr << (const char*)(report->filename? report->filename : "<no filename>") << ":" - << (unsigned int)report->lineno << ":" << message << std::endl; + cerr << (const char*)(report->filename? report->filename : "<no filename>") << ":" + << (int)report->lineno << ":" << message << endl; } /** @@ -168,7 +168,7 @@ const list<value> jsPropertiesToValues(const list<value>& propertiesSoFar, JSObj const value jsValToValue(const jsval& jsv, const JSONContext& cx) { switch(JS_TypeOfValue(cx, jsv)) { case JSTYPE_STRING: { - return value(std::string(JS_GetStringBytes(JSVAL_TO_STRING(jsv)))); + return value(string(JS_GetStringBytes(JSVAL_TO_STRING(jsv)))); } case JSTYPE_BOOLEAN: { return value((bool)JSVAL_TO_BOOLEAN(jsv)); @@ -195,30 +195,30 @@ const value jsValToValue(const jsval& jsv, const JSONContext& cx) { /** * Consumes JSON strings and populates a JS object. */ -failable<bool, std::string> consume(JSONParser* parser, const list<std::string>& ilist, const JSONContext& cx) { +failable<bool> consume(JSONParser* parser, const list<string>& ilist, const JSONContext& cx) { if (isNil(ilist)) return true; - JSString* jstr = JS_NewStringCopyZ(cx, car(ilist).c_str()); + JSString* jstr = JS_NewStringCopyZ(cx, c_str(car(ilist))); if(!JS_ConsumeJSONText(cx, parser, JS_GetStringChars(jstr), JS_GetStringLength(jstr))) - return mkfailure<bool, std::string>("JS_ConsumeJSONText failed"); + return mkfailure<bool>("JS_ConsumeJSONText failed"); return consume(parser, cdr(ilist), cx); } /** * Convert a list of strings representing a JSON document to a list of values. */ -const failable<list<value>, std::string> readJSON(const list<std::string>& ilist, const JSONContext& cx) { +const failable<list<value> > readJSON(const list<string>& ilist, const JSONContext& cx) { jsval val; JSONParser* parser = JS_BeginJSONParse(cx, &val); if(parser == NULL) - return mkfailure<list<value>, std::string>("JS_BeginJSONParse failed"); + return mkfailure<list<value> >("JS_BeginJSONParse failed"); - const failable<bool, std::string> consumed = consume(parser, ilist, cx); + const failable<bool> consumed = consume(parser, ilist, cx); if(!JS_FinishJSONParse(cx, parser, JSVAL_NULL)) - return mkfailure<list<value>, std::string>("JS_FinishJSONParse failed"); + return mkfailure<list<value> >("JS_FinishJSONParse failed"); if(!hasContent(consumed)) - return mkfailure<list<value>, std::string>(reason(consumed)); + return mkfailure<list<value> >(reason(consumed)); return list<value>(jsValToValue(val, cx)); } @@ -261,7 +261,7 @@ JSObject* valuesToJSProperties(JSObject* o, const list<value>& l, const JSONCont return o; const list<value> p = car(l); jsval pv = valueToJSVal(caddr(p), cx); - JS_SetProperty(cx, o, ((std::string)cadr(p)).c_str(), &pv); + JS_SetProperty(cx, o, c_str((string)cadr(p)), &pv); return valuesToJSProperties(o, cdr(l), cx); } @@ -272,7 +272,7 @@ const jsval valueToJSVal(const value& val, const JSONContext& cx) { switch(type(val)) { case value::String: case value::Symbol: { - return STRING_TO_JSVAL(JS_NewStringCopyZ(cx, ((std::string)val).c_str())); + return STRING_TO_JSVAL(JS_NewStringCopyZ(cx, c_str((string)val))); } case value::Bool: { return BOOLEAN_TO_JSVAL((bool)val); @@ -291,7 +291,7 @@ const jsval valueToJSVal(const value& val, const JSONContext& cx) { } } -const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, const JSONContext& cx) { +const failable<bool> writeList(const list<value>& l, JSObject* o, const JSONContext& cx) { if (isNil(l)) return true; @@ -300,24 +300,24 @@ const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, c if (isTaggedList(token, attribute)) { jsval pv = valueToJSVal(attributeValue(token), cx); - JS_SetProperty(cx, o, std::string(attributeName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(attributeName(token))), &pv); } else if (isTaggedList(token, element)) { // Write the value of an element if (elementHasValue(token)) { jsval pv = valueToJSVal(elementValue(token), cx); - JS_SetProperty(cx, o, std::string(elementName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(elementName(token))), &pv); } else { // Write a parent element JSObject* child = JS_NewObject(cx, NULL, NULL, NULL); jsval pv = OBJECT_TO_JSVAL(child); - JS_SetProperty(cx, o, std::string(elementName(token)).c_str(), &pv); + JS_SetProperty(cx, o, c_str(string(elementName(token))), &pv); // Write its children - const failable<bool, std::string> w = writeList(elementChildren(token), child, cx); + const failable<bool> w = writeList(elementChildren(token), child, cx); if (!hasContent(w)) return w; } @@ -332,10 +332,10 @@ const failable<bool, std::string> writeList(const list<value>& l, JSObject* o, c */ template<typename R> class WriteContext { public: - WriteContext(const lambda<R(const std::string&, const R)>& reduce, const R& accum, const JSONContext& cx) : cx(cx), reduce(reduce), accum(accum) { + WriteContext(const lambda<R(const string&, const R)>& reduce, const R& accum, const JSONContext& cx) : cx(cx), reduce(reduce), accum(accum) { } const JSONContext& cx; - const lambda<R(const std::string&, const R)> reduce; + const lambda<R(const string&, const R)> reduce; R accum; }; @@ -345,40 +345,40 @@ public: template<typename R> JSBool writeCallback(const jschar *buf, uint32 len, void *data) { WriteContext<R>& wcx = *(static_cast<WriteContext<R>*> (data)); JSString* jstr = JS_NewUCStringCopyN(wcx.cx, buf, len); - wcx.accum = wcx.reduce(std::string(JS_GetStringBytes(jstr), JS_GetStringLength(jstr)), wcx.accum); + wcx.accum = wcx.reduce(string(JS_GetStringBytes(jstr), JS_GetStringLength(jstr)), wcx.accum); return JS_TRUE; } /** * Convert a list of values to a JSON document. */ -template<typename R> const failable<R, std::string> writeJSON(const lambda<R(const std::string&, const R)>& reduce, const R& initial, const list<value>& l, const JSONContext& cx) { +template<typename R> const failable<R> writeJSON(const lambda<R(const string&, const R)>& reduce, const R& initial, const list<value>& l, const JSONContext& cx) { JSObject* o = JS_NewObject(cx, NULL, NULL, NULL); jsval val = OBJECT_TO_JSVAL(o); - const failable<bool, std::string> w = writeList(l, o, cx); + const failable<bool> w = writeList(l, o, cx); if (!hasContent(w)) - return mkfailure<R, std::string>(reason(w)); + return mkfailure<R>(reason(w)); WriteContext<R> wcx(reduce, initial, cx); if (!JS_Stringify(cx, &val, NULL, JSVAL_NULL, writeCallback<R>, &wcx)) - return mkfailure<R, std::string>("JS_Stringify failed"); + return mkfailure<R>("JS_Stringify failed"); return wcx.accum; } /** * Convert a list of values to a list of strings representing a JSON document. */ -const failable<list<std::string>, std::string> writeJSON(const list<value>& l, const JSONContext& cx) { - const failable<list<std::string>, std::string> ls = writeJSON<list<std::string> >(rcons<std::string>, list<std::string>(), l, cx); +const failable<list<string> > writeJSON(const list<value>& l, const JSONContext& cx) { + const failable<list<string> > ls = writeJSON<list<string>>(rcons<string>, list<string>(), l, cx); if (!hasContent(ls)) return ls; - return reverse(list<std::string>(content(ls))); + return reverse(list<string>(content(ls))); } /** * Convert a function + params to a JSON request. */ -const failable<list<std::string>, std::string> jsonRequest(const value& id, const value& func, const value& params, json::JSONContext& cx) { +const failable<list<string> > jsonRequest(const value& id, const value& func, const value& params, json::JSONContext& cx) { const list<value> r = mklist<value>(mklist<value>("id", id), mklist<value>("method", func), mklist<value>("params", params)); return writeJSON(valuesToElements(r), cx); } @@ -386,7 +386,7 @@ const failable<list<std::string>, std::string> jsonRequest(const value& id, cons /** * Convert a value to a JSON result. */ -const failable<list<std::string>, std::string> jsonResult(const value& id, const value& val, JSONContext& cx) { +const failable<list<string> > jsonResult(const value& id, const value& val, JSONContext& cx) { return writeJSON(valuesToElements(mklist<value>(mklist<value>("id", id), mklist<value>("result", val))), cx); } diff --git a/sca-cpp/trunk/modules/scdl/scdl-test.cpp b/sca-cpp/trunk/modules/scdl/scdl-test.cpp index 582d1ee073..d6034d1e2f 100644 --- a/sca-cpp/trunk/modules/scdl/scdl-test.cpp +++ b/sca-cpp/trunk/modules/scdl/scdl-test.cpp @@ -24,12 +24,9 @@ */ #include <assert.h> -#include <iostream> -#include <sstream> -#include <fstream> -#include <string> +#include "stream.hpp" +#include "string.hpp" #include "list.hpp" -#include "slist.hpp" #include "tree.hpp" #include "scdl.hpp" @@ -37,24 +34,24 @@ namespace tuscany { namespace scdl { bool testComposite() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = readXML(streamList(is)); return true; } bool testComponents() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); assert(length(c) == 4); const value store = car(c); - assert(name(store) == std::string("Store")); + assert(name(store) == string("Store")); const value impl = implementation(store); - assert(uri(impl) == std::string("store.html")); + assert(uri(impl) == string("store.html")); assert(implementationType(impl) == "t:implementation.widget"); - const value catalog = named(std::string("Catalog"), c); - assert(name(catalog) == std::string("Catalog")); + const value catalog = named(string("Catalog"), c); + assert(name(catalog) == string("Catalog")); const list<value> t = mkbtree(sort(nameToElementAssoc(c))); assert(assoctree<value>("Catalog", t) == mklist<value>("Catalog" , cadr(c))); @@ -62,30 +59,30 @@ bool testComponents() { } bool testServices() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); const value store = car(c); assert(length(services(store)) == 1); const value widget = car(services(store)); - assert(name(widget) == std::string("Widget")); + assert(name(widget) == string("Widget")); assert(length(bindings(widget)) == 1); const value binding = car(bindings(widget)); - assert(uri(binding) == std::string("/store")); + assert(uri(binding) == string("/store")); assert(bindingType(binding) == "t:binding.http"); return true; } bool testReferences() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); const value store = car(c); assert(length(references(store)) == 3); const value catalog = car(references(store)); - assert(name(catalog) == std::string("catalog")); - assert(target(catalog) == std::string("Catalog")); + assert(name(catalog) == string("catalog")); + assert(target(catalog) == string("Catalog")); assert(length(bindings(catalog)) == 1); const value binding = car(bindings(catalog)); @@ -93,19 +90,19 @@ bool testReferences() { assert(bindingType(binding) == "t:binding.jsonrpc"); const list<value> t = mkbtree(sort(referenceToTargetAssoc(references(store)))); - assert(assoctree<value>("shoppingCart", t) == mklist<value>(std::string("shoppingCart"), std::string("ShoppingCart/Cart"))); + assert(assoctree<value>("shoppingCart", t) == mklist<value>(string("shoppingCart"), string("ShoppingCart/Cart"))); return true; } bool testProperties() { - std::ifstream is("test.composite"); + ifstream is("test.composite"); const list<value> c = components(readXML(streamList(is))); - const value catalog = named(std::string("Catalog"), c); + const value catalog = named(string("Catalog"), c); assert(length(properties(catalog)) == 1); const value currencyCode = car(properties(catalog)); - assert(name(currencyCode) == std::string("currencyCode")); - assert(propertyValue(currencyCode) == std::string("USD")); + assert(name(currencyCode) == string("currencyCode")); + assert(propertyValue(currencyCode) == string("USD")); return true; } @@ -113,7 +110,7 @@ bool testProperties() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::scdl::testComposite(); tuscany::scdl::testComponents(); @@ -121,7 +118,7 @@ int main() { tuscany::scdl::testReferences(); tuscany::scdl::testProperties(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/scdl/scdl.hpp b/sca-cpp/trunk/modules/scdl/scdl.hpp index 9d4bf38b50..531144e219 100644 --- a/sca-cpp/trunk/modules/scdl/scdl.hpp +++ b/sca-cpp/trunk/modules/scdl/scdl.hpp @@ -26,7 +26,7 @@ * SCDL read functions. */ -#include <string> +#include "string.hpp" #include "list.hpp" #include "value.hpp" #include "monad.hpp" @@ -85,7 +85,7 @@ const value named(const value& name, const value& l) { * Returns the implementation of a component. */ const bool filterImplementation(const value& v) { - return isElement(v) && std::string(cadr<value>(v)).find("implementation.") != std::string::npos; + return isElement(v) && contains(string(cadr<value>(v)), "implementation."); } const value implementation(const value& l) { @@ -137,7 +137,7 @@ const list<value> referenceToTargetAssoc(const list<value>& r) { * Returns a list of bindings in a service or reference. */ const bool filterBinding(const value& v) { - return isElement(v) && std::string(cadr<value>(v)).find("binding.") != std::string::npos; + return isElement(v) && contains(string(cadr<value>(v)), "binding."); } const list<value> bindings(const value& l) { diff --git a/sca-cpp/trunk/modules/server/client-test.cpp b/sca-cpp/trunk/modules/server/client-test.cpp index 496d67f59c..2728cfc6d5 100644 --- a/sca-cpp/trunk/modules/server/client-test.cpp +++ b/sca-cpp/trunk/modules/server/client-test.cpp @@ -23,11 +23,12 @@ * Test HTTP client functions. */ +#include <sys/types.h> +#include <sys/wait.h> +#include <unistd.h> #include <assert.h> -#include <iostream> -#include <sstream> -#include <string> -#include "slist.hpp" +#include "stream.hpp" +#include "string.hpp" #include "parallel.hpp" #include "perf.hpp" #include "../http/curl.hpp" @@ -35,11 +36,7 @@ namespace tuscany { namespace server { -const bool contains(const std::string& str, const std::string& pattern) { - return str.find(pattern) != str.npos; -} - -std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { +ostream* curlWriter(const string& s, ostream* os) { (*os) << s; return os; } @@ -47,16 +44,16 @@ std::ostringstream* curlWriter(const std::string& s, std::ostringstream* os) { const bool testGet() { http::CURLSession ch; { - std::ostringstream os; - const failable<list<std::ostringstream*>, std::string> r = http::get<std::ostringstream*>(curlWriter, &os, "http://localhost:8090", ch); + ostringstream os; + const failable<list<ostream*> > r = http::get<ostream*>(curlWriter, &os, "http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(os.str(), "HTTP/1.1 200 OK")); - assert(contains(os.str(), "It works")); + assert(contains(str(os), "HTTP/1.1 200 OK")); + assert(contains(str(os), "It works")); } { - const failable<value, std::string> r = http::get("http://localhost:8090", ch); + const failable<value> r = http::getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); } return true; } @@ -66,9 +63,9 @@ struct getLoop { getLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const failable<value, std::string> r = get("http://localhost:8090", ch); + const failable<value> r = http::getcontent("http://localhost:8090", ch); assert(hasContent(r)); - assert(contains(content(r), "It works")); + assert(contains(car(reverse(list<value>(content(r)))), "It works")); return true; } }; @@ -76,14 +73,14 @@ struct getLoop { const bool testGetPerf() { http::CURLSession ch; const lambda<bool()> gl = getLoop(ch); - std::cout << "Static GET test " << time(gl, 5, 200) << " ms" << std::endl; + cout << "Static GET test " << time(gl, 5, 200) << " ms" << endl; return true; } const bool testEval() { http::CURLSession ch; - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), std::string("Hello")), "http://localhost:8090/test", ch)); - assert(val == std::string("Hello")); + const value val = content(http::evalExpr(mklist<value>(string("echo"), string("Hello")), "http://localhost:8090/test", ch)); + assert(val == string("Hello")); return true; } @@ -92,13 +89,13 @@ struct evalLoop { evalLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), std::string("Hello")), "http://localhost:8090/test", ch)); - assert(val == std::string("Hello")); + const value val = content(http::evalExpr(mklist<value>(string("echo"), string("Hello")), "http://localhost:8090/test", ch)); + assert(val == string("Hello")); return true; } }; -const value blob(std::string(3000, 'A')); +const value blob(string(3000, 'A')); const list<value> blobs = mklist(blob, blob, blob, blob, blob); struct blobEvalLoop { @@ -106,7 +103,7 @@ struct blobEvalLoop { blobEvalLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("echo"), blobs), "http://localhost:8090/test", ch)); + const value val = content(http::evalExpr(mklist<value>(string("echo"), blobs), "http://localhost:8090/test", ch)); assert(val == blobs); return true; } @@ -115,19 +112,19 @@ struct blobEvalLoop { const bool testEvalPerf() { http::CURLSession ch; const lambda<bool()> el = evalLoop(ch); - std::cout << "JSON-RPC eval echo test " << time(el, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC eval echo test " << time(el, 5, 200) << " ms" << endl; const lambda<bool()> bel = blobEvalLoop(ch); - std::cout << "JSON-RPC eval blob test " << time(bel, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC eval blob test " << time(bel, 5, 200) << " ms" << endl; return true; } bool testPost() { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); http::CURLSession ch; - const failable<value, std::string> id = http::post(a, "http://localhost:8090/test", ch); + const failable<value> id = http::post(a, "http://localhost:8090/test", ch); assert(hasContent(id)); return true; } @@ -138,7 +135,7 @@ struct postLoop { postLoop(const value& val, http::CURLSession& ch) : val(val), ch(ch) { } const bool operator()() const { - const failable<value, std::string> id = http::post(val, "http://localhost:8090/test", ch); + const failable<value> id = http::post(val, "http://localhost:8090/test", ch); assert(hasContent(id)); return true; } @@ -148,28 +145,30 @@ const bool testPostPerf() { http::CURLSession ch; { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl = postLoop(val, ch); - std::cout << "ATOMPub POST small test " << time(pl, 5, 200) << " ms" << std::endl; + cout << "ATOMPub POST small test " << time(pl, 5, 200) << " ms" << endl; } { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "blob1" << blob) - << (list<value>() << "blob2" << blob) - << (list<value>() << "blob3" << blob) - << (list<value>() << "blob4" << blob) - << (list<value>() << "blob5" << blob) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "blob1" + blob) + + (list<value>() + "blob2" + blob) + + (list<value>() + "blob3" + blob) + + (list<value>() + "blob4" + blob) + + (list<value>() + "blob5" + blob) + + (list<value>() + "price" + string("$2.99")); + const list<value> val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl = postLoop(val, ch); - std::cout << "ATOMPub POST blob test " << time(pl, 5, 200) << " ms" << std::endl; + cout << "ATOMPub POST blob test " << time(pl, 5, 200) << " ms" << endl; } return true; } +#ifdef _REENTRANT + const bool postThread(const int count, const value& val) { http::CURLSession ch; const lambda<bool()> pl = postLoop(val, ch); @@ -194,7 +193,7 @@ struct postThreadLoop { const lambda<bool()> l; const int threads; const gc_ptr<worker> w; - postThreadLoop(const lambda<bool()>& l, const int threads) : l(l), threads(threads), w(new worker(threads)) { + postThreadLoop(const lambda<bool()>& l, const int threads) : l(l), threads(threads), w(new (gc_new<worker>()) worker(threads)) { } const bool operator()() const { list<future<bool> > r = startPost(*w, threads, l); @@ -208,23 +207,83 @@ const bool testPostThreadPerf() { const int threads = 10; const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const value val = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const value val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); const lambda<bool()> pl= curry(lambda<bool(const int, const value)>(postThread), count, val); const lambda<bool()> ptl = postThreadLoop(pl, threads); double t = time(ptl, 0, 1) / (threads * count); - std::cout << "ATOMPub POST thread test " << t << " ms" << std::endl; + cout << "ATOMPub POST thread test " << t << " ms" << endl; return true; } +#else + +const bool postProc(const int count, const value& val) { + http::CURLSession ch; + const lambda<bool()> pl = postLoop(val, ch); + time(pl, 0, count); + return true; +} + +const list<pid_t> startPost(const int procs, const lambda<bool()>& l) { + if (procs == 0) + return list<pid_t>(); + pid_t pid = fork(); + if (pid == 0) { + assert(l() == true); + exit(0); + } + return cons(pid, startPost(procs - 1, l)); +} + +const bool checkPost(const list<pid_t>& r) { + if (isNil(r)) + return true; + int status; + waitpid(car(r), &status, 0); + assert(status == 0); + return checkPost(cdr(r)); +} + +struct postForkLoop { + const lambda<bool()> l; + const int procs; + postForkLoop(const lambda<bool()>& l, const int procs) : l(l), procs(procs) { + } + const bool operator()() const { + list<pid_t> r = startPost(procs, l); + checkPost(r); + return true; + } +}; + +const bool testPostForkPerf() { + const int count = 50; + const int procs = 10; + + const list<value> i = list<value>() + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const value val = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + const lambda<bool()> pl= curry(lambda<bool(const int, const value)>(postProc), count, val); + const lambda<bool()> ptl = postForkLoop(pl, procs); + double t = time(ptl, 0, 1) / (procs * count); + cout << "ATOMPub POST fork test " << t << " ms" << endl; + + return true; +} + +#endif + const bool testPut() { const list<value> i = list<value>() - << (list<value>() << "name" << std::string("Apple")) - << (list<value>() << "price" << std::string("$2.99")); - const list<value> a = mklist<value>(std::string("item"), std::string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); + + (list<value>() + "name" + string("Apple")) + + (list<value>() + "price" + string("$2.99")); + const list<value> a = mklist<value>(string("item"), string("cart-53d67a61-aa5e-4e5e-8401-39edeba8b83b"), i); http::CURLSession ch; value rc = content(http::put(a, "http://localhost:8090/test/111", ch)); assert(rc == value(true)); @@ -240,8 +299,8 @@ const bool testDel() { const bool testEvalCpp() { http::CURLSession ch; - const value val = content(http::evalExpr(mklist<value>(std::string("hello"), std::string("world")), "http://localhost:8090/cpp", ch)); - assert(val == std::string("hello world")); + const value val = content(http::evalExpr(mklist<value>(string("hello"), string("world")), "http://localhost:8090/cpp", ch)); + assert(val == string("hello world")); return true; } @@ -250,8 +309,8 @@ struct evalCppLoop { evalCppLoop(http::CURLSession& ch) : ch(ch) { } const bool operator()() const { - const value val = content(http::evalExpr(mklist<value>(std::string("hello"), std::string("world")), "http://localhost:8090/cpp", ch)); - assert(val == std::string("hello world")); + const value val = content(http::evalExpr(mklist<value>(string("hello"), string("world")), "http://localhost:8090/cpp", ch)); + assert(val == string("hello world")); return true; } }; @@ -259,7 +318,7 @@ struct evalCppLoop { const bool testEvalCppPerf() { http::CURLSession ch; const lambda<bool()> el = evalCppLoop(ch); - std::cout << "JSON-RPC C++ eval test " << time(el, 5, 200) << " ms" << std::endl; + cout << "JSON-RPC C++ eval test " << time(el, 5, 200) << " ms" << endl; return true; } @@ -267,13 +326,17 @@ const bool testEvalCppPerf() { } int main() { - std::cout << "Testing..." << std::endl; + tuscany::cout << "Testing..." << tuscany::endl; tuscany::server::testGet(); tuscany::server::testGetPerf(); tuscany::server::testPost(); tuscany::server::testPostPerf(); +#ifdef _REENTRANT tuscany::server::testPostThreadPerf(); +#else + tuscany::server::testPostForkPerf(); +#endif tuscany::server::testEval(); tuscany::server::testEvalPerf(); tuscany::server::testPut(); @@ -281,7 +344,7 @@ int main() { tuscany::server::testEvalCpp(); tuscany::server::testEvalCppPerf(); - std::cout << "OK" << std::endl; + tuscany::cout << "OK" << tuscany::endl; return 0; } diff --git a/sca-cpp/trunk/modules/server/impl-test.cpp b/sca-cpp/trunk/modules/server/impl-test.cpp index 171a78f2d5..d2a45c2fa9 100644 --- a/sca-cpp/trunk/modules/server/impl-test.cpp +++ b/sca-cpp/trunk/modules/server/impl-test.cpp @@ -23,7 +23,7 @@ * Test component implementation. */ -#include <string> +#include "string.hpp" #include "function.hpp" #include "list.hpp" @@ -34,24 +34,24 @@ namespace tuscany { namespace server { -const failable<value, std::string> get(unused const list<value>& params) { - return value(std::string("Hey")); +const failable<value> get(unused const list<value>& params) { + return value(string("Hey")); } -const failable<value, std::string> post(unused const list<value>& params) { - return value(std::string("1234")); +const failable<value> post(unused const list<value>& params) { + return value(string("1234")); } -const failable<value, std::string> put(unused const list<value>& params) { +const failable<value> put(unused const list<value>& params) { return value(true); } -const failable<value, std::string> del(unused const list<value>& params) { +const failable<value> del(unused const list<value>& params) { return value(true); } -const failable<value, std::string> hello(const list<value>& params) { - return value(std::string("hello ") + std::string(car(params))); +const failable<value> hello(const list<value>& params) { + return value(string("hello ") + string(car(params))); } } @@ -71,7 +71,7 @@ const tuscany::value eval(const tuscany::list<tuscany::value>& params) { return tuscany::server::del(cdr(params)); if (func == "hello") return tuscany::server::hello(cdr(params)); - return tuscany::mkfailure<tuscany::value, std::string>(std::string("Function not supported: ") + std::string(func)); + return tuscany::mkfailure<tuscany::value>(tuscany::string("Function not supported: ") + func); } } diff --git a/sca-cpp/trunk/modules/server/mod-cpp.hpp b/sca-cpp/trunk/modules/server/mod-cpp.hpp index 664e9d2e41..2cf2e540d6 100644 --- a/sca-cpp/trunk/modules/server/mod-cpp.hpp +++ b/sca-cpp/trunk/modules/server/mod-cpp.hpp @@ -27,9 +27,8 @@ * component implementations. */ -#include <string> -#include <iostream> -#include <fstream> +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" @@ -65,12 +64,12 @@ struct evalImplementation { /** * Read a C++ component implementation. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string path, const list<value>& px) { - const failable<lib, std::string> ilib(dynlib(path + dynlibExt)); +const failable<lambda<value(const list<value>&)> > readImplementation(const string& path, const list<value>& px) { + const failable<lib> ilib(dynlib(path + dynlibExt)); if (!hasContent(ilib)) - return mkfailure<lambda<value(const list<value>&)>, std::string>(reason(ilib)); + return mkfailure<lambda<value(const list<value>&)> >(reason(ilib)); - const failable<lambda<value(const list<value>&)>, std::string> impl(dynlambda<value(const list<value>&)>("eval", content(ilib))); + const failable<lambda<value(const list<value>&)> > impl(dynlambda<value(const list<value>&)>("eval", content(ilib))); if (!hasContent(impl)) return impl; return lambda<value(const list<value>&)>(evalImplementation(content(ilib), content(impl), px)); diff --git a/sca-cpp/trunk/modules/server/mod-eval.cpp b/sca-cpp/trunk/modules/server/mod-eval.cpp index d8354c6a58..8e8870dd52 100644 --- a/sca-cpp/trunk/modules/server/mod-eval.cpp +++ b/sca-cpp/trunk/modules/server/mod-eval.cpp @@ -23,15 +23,11 @@ * HTTPD module used to eval component implementations. */ -#include <string> -#include <iostream> -#include <sstream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "tree.hpp" -#include "slist.hpp" #include "value.hpp" #include "element.hpp" #include "monad.hpp" @@ -58,9 +54,10 @@ class ServerConf { public: ServerConf(server_rec* s) : s(s), home(""), wiringServerName("") { } + const server_rec* s; - std::string home; - std::string wiringServerName; + string home; + string wiringServerName; }; /** @@ -71,8 +68,8 @@ public: DirConf(char* dirspec) : dirspec(dirspec), contributionPath(""), compositeName("") { } const char* dirspec; - std::string contributionPath; - std::string compositeName; + string contributionPath; + string compositeName; list<value> implementations; }; @@ -80,16 +77,16 @@ public: * Convert a result represented as a content + failure pair to a * failable monad. */ -const failable<value, std::string> failableResult(const list<value>& v) { +const failable<value> failableResult(const list<value>& v) { if (isNil(cdr(v))) return car(v); - return mkfailure<value, std::string>(cadr(v)); + return mkfailure<value>(string(cadr(v))); } /** * Handle an HTTP GET. */ -const failable<int, std::string> get(request_rec* r, const lambda<value(const list<value>&)>& impl) { +const failable<int> get(request_rec* r, const lambda<value(const list<value>&)>& impl) { debug(r->uri, "modeval::get::uri"); // Inspect the query string @@ -102,12 +99,12 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li // Extract the request id, method and params const value id = cadr(ia); - const value func = std::string(cadr(ma)).c_str(); + const value func = c_str(string(cadr(ma))); // Apply the requested function - const failable<value, std::string> val = failableResult(impl(cons(func, httpd::queryParams(args)))); + const failable<value> val = failableResult(impl(cons(func, httpd::queryParams(args)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return JSON result json::JSONContext cx; @@ -115,58 +112,58 @@ const failable<int, std::string> get(request_rec* r, const lambda<value(const li } // Evaluate an ATOM GET request and return an ATOM feed - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); if (isNil(cddr(path))) { - const failable<value, std::string> val = failableResult(impl(cons<value>("getall", list<value>()))); + const failable<value> val = failableResult(impl(cons<value>("getall", list<value>()))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); return httpd::writeResult(atom::writeATOMFeed(atom::feedValuesToElements(content(val))), "application/atom+xml;type=feed", r); } // Evaluate an ATOM GET and return an ATOM entry - const failable<value, std::string> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path))))); + const failable<value> val = failableResult(impl(cons<value>("get", mklist<value>(caddr(path))))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); return httpd::writeResult(atom::writeATOMEntry(atom::entryValuesToElements(content(val))), "application/atom+xml;type=entry", r); } /** * Handle an HTTP POST. */ -const failable<int, std::string> post(request_rec* r, const lambda<value(const list<value>&)>& impl) { - const list<std::string> ls = httpd::read(r); +const failable<int> post(request_rec* r, const lambda<value(const list<value>&)>& impl) { + const list<string> ls = httpd::read(r); debug(r->uri, "modeval::post::url"); debug(ls, "modeval::post::input"); // Evaluate a JSON-RPC request and return a JSON result - const std::string ct = httpd::contentType(r); - if (ct.find("application/json-rpc") != std::string::npos || ct.find("text/plain") != std::string::npos) { + const string ct = httpd::contentType(r); + if (contains(ct, "application/json-rpc") || contains(ct, "text/plain")) { json::JSONContext cx; const list<value> json = elementsToValues(content(json::readJSON(ls, cx))); const list<list<value> > args = httpd::postArgs(json); // Extract the request id, method and params const value id = cadr(assoc(value("id"), args)); - const value func = std::string(cadr(assoc(value("method"), args))).c_str(); + const value func = c_str(cadr(assoc(value("method"), args))); const list<value> params = (list<value>)cadr(assoc(value("params"), args)); // Evaluate the request expression - const failable<value, std::string> val = failableResult(impl(cons<value>(func, params))); + const failable<value> val = failableResult(impl(cons<value>(func, params))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return JSON result return httpd::writeResult(json::jsonResult(id, content(val), cx), "application/json-rpc", r); } // Evaluate an ATOM POST request and return the created resource location - if (ct.find("application/atom+xml") != std::string::npos) { + if (contains(ct, "application/atom+xml")) { // Evaluate the request expression const value entry = atom::entryValue(content(atom::readEntry(ls))); - const failable<value, std::string> val = failableResult(impl(cons<value>("post", mklist<value>(entry)))); + const failable<value> val = failableResult(impl(cons<value>("post", mklist<value>(entry)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); // Return the created resource location apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, httpd::url(content(val), r))); @@ -180,17 +177,17 @@ const failable<int, std::string> post(request_rec* r, const lambda<value(const l /** * Handle an HTTP PUT. */ -const failable<int, std::string> put(request_rec* r, const lambda<value(const list<value>&)>& impl) { - const list<std::string> ls = httpd::read(r); +const failable<int> put(request_rec* r, const lambda<value(const list<value>&)>& impl) { + const list<string> ls = httpd::read(r); debug(r->uri, "modeval::put::url"); debug(ls, "modeval::put::input"); // Evaluate an ATOM PUT request - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const value entry = atom::entryValue(content(atom::readEntry(ls))); - const failable<value, std::string> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry)))); + const failable<value> val = failableResult(impl(cons<value>("put", mklist<value>(caddr(path), entry)))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); if (val == value(false)) return HTTP_NOT_FOUND; return OK; @@ -199,14 +196,14 @@ const failable<int, std::string> put(request_rec* r, const lambda<value(const li /** * Handle an HTTP DELETE. */ -const failable<int, std::string> del(request_rec* r, const lambda<value(const list<value>&)>& impl) { +const failable<int> del(request_rec* r, const lambda<value(const list<value>&)>& impl) { debug(r->uri, "modeval::delete::url"); // Evaluate an ATOM delete request - const list<value> path(httpd::path(r->uri)); - const failable<value, std::string> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path))))); + const list<value> path(httpd::pathValues(r->uri)); + const failable<value> val = failableResult(impl(cons<value>("delete", mklist<value>(caddr(path))))); if (!hasContent(val)) - return mkfailure<int, std::string>(reason(val)); + return mkfailure<int>(reason(val)); if (val == value(false)) return HTTP_NOT_FOUND; return OK; @@ -216,6 +213,7 @@ const failable<int, std::string> del(request_rec* r, const lambda<value(const li * Translate a component request. */ int translate(request_rec *r) { + gc_scoped_pool pool(r->pool); if (strncmp(r->uri, "/components/", 12) != 0) return DECLINED; r->handler = "mod_tuscany_eval"; @@ -226,6 +224,7 @@ int translate(request_rec *r) { * HTTP request handler. */ int handler(request_rec *r) { + gc_scoped_pool pool(r->pool); if(strcmp(r->handler, "mod_tuscany_eval")) return DECLINED; httpdDebugRequest(r, "modeval::handler::input"); @@ -237,7 +236,7 @@ int handler(request_rec *r) { // Get the component implementation lambda DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_eval); - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const list<value> impl(assoctree<value>(cadr(path), dc.implementations)); if (isNil(impl)) return HTTP_NOT_FOUND; @@ -260,11 +259,11 @@ int handler(request_rec *r) { /** * Convert a list of component references to a list of HTTP proxy lambdas. */ -const value mkproxy(const value& ref, const std::string& base) { - return lambda<value(const list<value>&)>(http::proxy(base + std::string(scdl::name(ref)))); +const value mkproxy(const value& ref, const string& base) { + return lambda<value(const list<value>&)>(http::proxy(base + string(scdl::name(ref)))); } -const list<value> proxies(const list<value>& refs, const std::string& base) { +const list<value> proxies(const list<value>& refs, const string& base) { if (isNil(refs)) return refs; return cons(mkproxy(car(refs), base), proxies(cdr(refs), base)); @@ -274,31 +273,31 @@ const list<value> proxies(const list<value>& refs, const std::string& base) { * Return a configured component implementation. * For now only Scheme and C++ implementations are supported. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string& itype, const std::string& path, const list<value>& px) { - if (itype.find(".scheme") != std::string::npos) +const failable<lambda<value(const list<value>&)> > readImplementation(const string& itype, const string& path, const list<value>& px) { + if (contains(itype, ".scheme")) return scm::readImplementation(path, px); - if (itype.find(".cpp") != std::string::npos) + if (contains(itype, ".cpp")) return cpp::readImplementation(path, px); - return mkfailure<lambda<value(const list<value>&)>, std::string>("Unsupported implementation type: " + itype); + return mkfailure<lambda<value(const list<value>&)> >(string("Unsupported implementation type: ") + itype); } const value confImplementation(DirConf& dc, ServerConf& sc, server_rec& server, const value& comp) { const value impl = scdl::implementation(comp); - const std::string path = dc.contributionPath + std::string(scdl::uri(impl)); + const string path = dc.contributionPath + string(scdl::uri(impl)); // Convert component references to configured proxy lambdas - std::ostringstream base; + ostringstream base; if (sc.wiringServerName == "") base << (server.server_scheme == NULL? "http" : server.server_scheme) << "://" << (server.server_hostname == NULL? "localhost" : server.server_hostname) << ":" << (server.port == 0? 80 : server.port) - << "/references/" << std::string(scdl::name(comp)) << "/"; + << "/references/" << string(scdl::name(comp)) << "/"; else - base << sc.wiringServerName << "/references/" << std::string(scdl::name(comp)) << "/"; - const list<value> px(proxies(scdl::references(comp), base.str())); + base << sc.wiringServerName << "/references/" << string(scdl::name(comp)) << "/"; + const list<value> px(proxies(scdl::references(comp), str(base))); // Read and configure the implementation - const failable<lambda<value(const list<value>&)>, std::string> cimpl(readImplementation(elementName(impl), path, px)); + const failable<lambda<value(const list<value>&)> > cimpl(readImplementation(elementName(impl), path, px)); if (!hasContent(cimpl)) return reason(cimpl); return content(cimpl); @@ -320,10 +319,10 @@ const list<value> componentToImplementationTree(DirConf& dc, ServerConf& sc, ser /** * Read the components declared in a composite. */ -const failable<list<value>, std::string> readComponents(const std::string& path) { - std::ifstream is(path); - if (is.fail() || is.bad()) - return mkfailure<list<value>, std::string>("Could not read composite: " + path); +const failable<list<value> > readComponents(const string& path) { + ifstream is(path); + if (fail(is)) + return mkfailure<list<value> >(string("Could not read composite: ") + path); return scdl::components(readXML(streamList(is))); } @@ -333,7 +332,7 @@ const failable<list<value>, std::string> readComponents(const std::string& path) const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) { if (dc.contributionPath == "" || dc.compositeName == "") return true; - const failable<list<value>, std::string> comps = readComponents(dc.contributionPath + dc.compositeName); + const failable<list<value> > comps = readComponents(dc.contributionPath + dc.compositeName); if (!hasContent(comps)) return true; dc.implementations = componentToImplementationTree(dc, sc, server, content(comps)); @@ -345,16 +344,19 @@ const bool confComponents(DirConf& dc, ServerConf& sc, server_rec& server) { * Configuration commands. */ const char *confHome(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); sc.home = arg; return NULL; } const char *confWiringServerName(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); sc.wiringServerName = arg; return NULL; } const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); DirConf& dc = *(DirConf*)c; dc.contributionPath = arg; @@ -362,6 +364,7 @@ const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { return NULL; } const char *confComposite(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_eval); DirConf& dc = *(DirConf*)c; dc.compositeName = arg; @@ -384,10 +387,11 @@ int postConfig(unused apr_pool_t *p, unused apr_pool_t *plog, unused apr_pool_t return OK; } -void childInit(unused apr_pool_t* p, server_rec* svr_rec) { +void childInit(apr_pool_t* p, server_rec* svr_rec) { + gc_scoped_pool pool(p); ServerConf* c = (ServerConf*)ap_get_module_config(svr_rec->module_config, &mod_tuscany_eval); if(c == NULL) { - std::cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << std::endl; + cerr << "[Tuscany] Due to one or more errors mod_tuscany_eval loading failed. Causing apache to stop loading." << endl; exit(APEXIT_CHILDFATAL); } } diff --git a/sca-cpp/trunk/modules/server/mod-scm.hpp b/sca-cpp/trunk/modules/server/mod-scm.hpp index c454c6a216..887b1de968 100644 --- a/sca-cpp/trunk/modules/server/mod-scm.hpp +++ b/sca-cpp/trunk/modules/server/mod-scm.hpp @@ -27,10 +27,8 @@ * component implementations. */ -#include <string> -#include <iostream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "function.hpp" #include "list.hpp" #include "value.hpp" @@ -65,12 +63,12 @@ struct evalImplementation { const value operator()(const list<value>& params) const { const value expr = cons<value>(car(params), append(eval::quotedParameters(cdr(params)), px)); debug(expr, "modeval::scm::evalImplementation::input"); - gc_pool pool; + gc_pool pool(gc_current_pool()); eval::Env globalEnv = eval::setupEnvironment(pool); const value val = eval::evalScript(expr, impl, globalEnv, pool); debug(val, "modeval::scm::evalImplementation::result"); if (isNil(val)) - return mklist<value>(value(), std::string("Could not evaluate expression")); + return mklist<value>(value(), string("Could not evaluate expression")); return mklist<value>(val); } }; @@ -78,13 +76,13 @@ struct evalImplementation { /** * Read a script component implementation. */ -const failable<lambda<value(const list<value>&)>, std::string> readImplementation(const std::string path, const list<value>& px) { - std::ifstream is(path.c_str(), std::ios_base::in); - if (is.fail() || is.bad()) - return mkfailure<lambda<value(const list<value>&)>, std::string>("Could not read implementation: " + path); +const failable<lambda<value(const list<value>&)> > readImplementation(const string& path, const list<value>& px) { + ifstream is(path); + if (fail(is)) + return mkfailure<lambda<value(const list<value>&)> >(string("Could not read implementation: ") + path); const value impl = eval::readScript(is); if (isNil(impl)) - return mkfailure<lambda<value(const list<value>&)>, std::string>("Could not read implementation: " + path); + return mkfailure<lambda<value(const list<value>&)> >(string("Could not read implementation: ") + path); return lambda<value(const list<value>&)>(evalImplementation(impl, px)); } diff --git a/sca-cpp/trunk/modules/server/mod-wiring.cpp b/sca-cpp/trunk/modules/server/mod-wiring.cpp index 1bb5d1a687..6b4308edda 100644 --- a/sca-cpp/trunk/modules/server/mod-wiring.cpp +++ b/sca-cpp/trunk/modules/server/mod-wiring.cpp @@ -26,13 +26,9 @@ #include <sys/stat.h> -#include <string> -#include <iostream> -#include <sstream> -#include <fstream> - +#include "string.hpp" +#include "stream.hpp" #include "list.hpp" -#include "slist.hpp" #include "tree.hpp" #include "value.hpp" #include "debug.hpp" @@ -56,8 +52,8 @@ public: ServerConf(server_rec* s) : s(s), home(""), wiringServerName("") { } const server_rec* s; - std::string home; - std::string wiringServerName; + string home; + string wiringServerName; }; /** @@ -73,8 +69,8 @@ public: DirConf(char* dirspec) : dirspec(dirspec), contributionPath(""), compositeName("") { } const char* dirspec; - std::string contributionPath; - std::string compositeName; + string contributionPath; + string compositeName; list<value> references; list<value> services; }; @@ -82,8 +78,8 @@ public: /** * Returns true if a URI is absolute. */ -const bool isAbsolute(const std::string& uri) { - return uri.find("://") != std::string::npos; +const bool isAbsolute(const string& uri) { + return contains(uri, "://"); } /** @@ -96,7 +92,7 @@ int translateReference(request_rec *r) { // Find the requested component DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_wiring); - const list<value> rpath(httpd::path(r->uri)); + const list<value> rpath(httpd::pathValues(r->uri)); const list<value> comp(assoctree(cadr(rpath), dc.references)); if (isNil(comp)) return HTTP_NOT_FOUND; @@ -105,26 +101,26 @@ int translateReference(request_rec *r) { const list<value> ref(assoctree<value>(caddr(rpath), cadr(comp))); if (isNil(ref)) return HTTP_NOT_FOUND; - const std::string target(cadr(ref)); + const string target(cadr(ref)); debug(target, "modwiring::translateReference::target"); // Route to an absolute target URI using mod_proxy or an HTTP client redirect if (isAbsolute(target)) { if (useModProxy) { - r->filename = apr_pstrdup(r->pool, std::string("proxy:" + target).c_str()); + r->filename = apr_pstrdup(r->pool, c_str(string("proxy:") + target)); r->proxyreq = PROXYREQ_REVERSE; r->handler = "proxy-server"; return OK; } r->status = HTTP_MOVED_TEMPORARILY; - apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, target.c_str())); + apr_table_setn(r->headers_out, "Location", apr_pstrdup(r->pool, c_str(target))); r->handler = "mod_tuscany_wiring"; return OK; } // Route to a relative target URI using a local internal redirect - r->filename = apr_pstrdup(r->pool, std::string("/redirect:/components/" + target).c_str()); + r->filename = apr_pstrdup(r->pool, c_str(string("/redirect:/components/") + target)); r->handler = "mod_tuscany_wiring"; return OK; } @@ -161,7 +157,7 @@ int translateService(request_rec *r) { // Find the requested component DirConf& dc = httpd::dirConf<DirConf>(r, &mod_tuscany_wiring); - const list<value> path(httpd::path(r->uri)); + const list<value> path(httpd::pathValues(r->uri)); const list<value> svc(assocPath(path, dc.services)); if (isNil(svc)) return DECLINED; @@ -172,9 +168,11 @@ int translateService(request_rec *r) { debug(target, "modwiring::translateService::target"); // Dispatch to the target component using a local internal redirect - const std::string redir(std::string("/redirect:/components") + httpd::path(target)); + const string p(httpd::path(target)); + debug(p, "modwiring::translateService::path"); + const string redir(string("/redirect:/components") + httpd::path(target)); debug(redir, "modwiring::translateService::redirect"); - r->filename = apr_pstrdup(r->pool, redir.c_str()); + r->filename = apr_pstrdup(r->pool, c_str(redir)); r->handler = "mod_tuscany_wiring"; return OK; } @@ -184,6 +182,7 @@ int translateService(request_rec *r) { * to the target component. */ int translate(request_rec *r) { + gc_scoped_pool pool(r->pool); if (!strncmp(r->uri, "/components/", 12) != 0) return DECLINED; @@ -198,11 +197,11 @@ int translate(request_rec *r) { /** * Construct a redirect URI. */ -const std::string redirect(const std::string& file, const std::string& pi) { +const string redirect(const string& file, const string& pi) { return file + pi; } -const std::string redirect(const std::string& file, const std::string& pi, const std::string& args) { +const string redirect(const string& file, const string& pi, const string& args) { return file + pi + "?" + args; } @@ -210,6 +209,7 @@ const std::string redirect(const std::string& file, const std::string& pi, const * HTTP request handler, redirect to a target component. */ int handler(request_rec *r) { + gc_scoped_pool pool(r->pool); if(strcmp(r->handler, "mod_tuscany_wiring")) return DECLINED; httpdDebugRequest(r, "modwiring::handler::input"); @@ -222,20 +222,20 @@ int handler(request_rec *r) { debug(r->path_info, "modwiring::handler::path info"); if (r->args == NULL) { - ap_internal_redirect(apr_pstrdup(r->pool, redirect(r->filename + 10, r->path_info).c_str()), r); + ap_internal_redirect(apr_pstrdup(r->pool, c_str(redirect(string(r->filename + 10), string(r->path_info)))), r); return OK; } - ap_internal_redirect(apr_pstrdup(r->pool, redirect(r->filename + 10, r->path_info, r->args).c_str()), r); + ap_internal_redirect(apr_pstrdup(r->pool, c_str(redirect(string(r->filename + 10), string(r->path_info), string(r->args)))), r); return OK; } /** * Read the components declared in a composite. */ -const failable<list<value>, std::string> readComponents(const std::string& path) { - std::ifstream is(path); - if (is.fail() || is.bad()) - return mkfailure<list<value>, std::string>("Could not read composite: " + path); +const failable<list<value> > readComponents(const string& path) { + ifstream is(path); + if (fail(is)) + return mkfailure<list<value> >(string("Could not read composite: ") + path); return scdl::components(readXML(streamList(is))); } @@ -261,23 +261,23 @@ const list<value> componentReferenceToTargetTree(const list<value>& c) { * Return a tree of service-URI-path + component-name pairs. Service-URI-paths are * represented as lists of URI path fragments. */ -const list<value> defaultBindingURI(const std::string& cn, const std::string& sn) { +const list<value> defaultBindingURI(const string& cn, const string& sn) { return mklist<value>(cn, sn); } -const list<value> bindingToComponentAssoc(const std::string& cn, const std::string& sn, const list<value>& b) { +const list<value> bindingToComponentAssoc(const string& cn, const string& sn, const list<value>& b) { if (isNil(b)) return b; const value uri(scdl::uri(car(b))); if (isNil(uri)) return cons<value>(mklist<value>(defaultBindingURI(cn, sn), cn), bindingToComponentAssoc(cn, sn, cdr(b))); - return cons<value>(mklist<value>(httpd::path(std::string(uri).c_str()), cn), bindingToComponentAssoc(cn, sn, cdr(b))); + return cons<value>(mklist<value>(httpd::pathValues(c_str(string(uri))), cn), bindingToComponentAssoc(cn, sn, cdr(b))); } -const list<value> serviceToComponentAssoc(const std::string& cn, const list<value>& s) { +const list<value> serviceToComponentAssoc(const string& cn, const list<value>& s) { if (isNil(s)) return s; - const std::string sn(scdl::name(car(s))); + const string sn(scdl::name(car(s))); const list<value> btoc(bindingToComponentAssoc(cn, sn, scdl::bindings(car(s)))); if (isNil(btoc)) return cons<value>(mklist<value>(defaultBindingURI(cn, sn), cn), serviceToComponentAssoc(cn, cdr(s))); @@ -300,7 +300,7 @@ const list<value> uriToComponentTree(const list<value>& c) { const bool confComponents(DirConf& dc) { if (dc.contributionPath == "" || dc.compositeName == "") return true; - const failable<list<value>, std::string> comps = readComponents(dc.contributionPath + dc.compositeName); + const failable<list<value> > comps = readComponents(dc.contributionPath + dc.compositeName); if (!hasContent(comps)) return true; dc.references = componentReferenceToTargetTree(content(comps)); @@ -314,22 +314,26 @@ const bool confComponents(DirConf& dc) { * Configuration commands. */ const char *confHome(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_wiring); sc.home = arg; return NULL; } const char *confWiringServerName(cmd_parms *cmd, unused void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); ServerConf& sc = httpd::serverConf<ServerConf>(cmd, &mod_tuscany_wiring); sc.wiringServerName = arg; return NULL; } -const char *confContribution(unused cmd_parms *cmd, void *c, const char *arg) { +const char *confContribution(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); DirConf& dc = *(DirConf*)c; dc.contributionPath = arg; confComponents(dc); return NULL; } -const char *confComposite(unused cmd_parms *cmd, void *c, const char *arg) { +const char *confComposite(cmd_parms *cmd, void *c, const char *arg) { + gc_scoped_pool pool(cmd->pool); DirConf& dc = *(DirConf*)c; dc.compositeName = arg; confComponents(dc); @@ -351,10 +355,11 @@ int postConfig(unused apr_pool_t *p, unused apr_pool_t *plog, unused apr_pool_t return OK; } -void childInit(unused apr_pool_t* p, server_rec* svr_rec) { +void childInit(apr_pool_t* p, server_rec* svr_rec) { + gc_scoped_pool pool(p); ServerConf *conf = (ServerConf*)ap_get_module_config(svr_rec->module_config, &mod_tuscany_wiring); if(conf == NULL) { - std::cerr << "[Tuscany] Due to one or more errors mod_tuscany_wiring loading failed. Causing apache to stop loading." << std::endl; + cerr << "[Tuscany] Due to one or more errors mod_tuscany_wiring loading failed. Causing apache to stop loading." << endl; exit(APEXIT_CHILDFATAL); } } |