tuscany-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jsdelf...@apache.org
Subject svn commit: r895165 [4/4] - in /tuscany/sca-cpp/trunk: ./ components/cache/ etc/ kernel/ modules/ modules/atom/ modules/eval/ modules/http/ modules/json/ modules/scdl/ modules/server/ test/store-script/
Date Sat, 02 Jan 2010 10:27:29 GMT
Modified: tuscany/sca-cpp/trunk/modules/server/mod-eval.cpp
URL: http://svn.apache.org/viewvc/tuscany/sca-cpp/trunk/modules/server/mod-eval.cpp?rev=895165&r1=895164&r2=895165&view=diff
==============================================================================
--- tuscany/sca-cpp/trunk/modules/server/mod-eval.cpp (original)
+++ tuscany/sca-cpp/trunk/modules/server/mod-eval.cpp Sat Jan  2 10:27:26 2010
@@ -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 @@
 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 @@
     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 @@
  * 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 @@
 
         // 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 @@
     }
 
     // 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 @@
 /**
  * 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 @@
 /**
  * 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 @@
  * 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 @@
  * 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 @@
 
     // 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 @@
 /**
  * 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 @@
  * 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 @@
 /**
  * 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 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 @@
  * 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 @@
     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 @@
     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);
     }
 }

Modified: tuscany/sca-cpp/trunk/modules/server/mod-scm.hpp
URL: http://svn.apache.org/viewvc/tuscany/sca-cpp/trunk/modules/server/mod-scm.hpp?rev=895165&r1=895164&r2=895165&view=diff
==============================================================================
--- tuscany/sca-cpp/trunk/modules/server/mod-scm.hpp (original)
+++ tuscany/sca-cpp/trunk/modules/server/mod-scm.hpp Sat Jan  2 10:27:26 2010
@@ -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 @@
     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 @@
 /**
  * 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));
 }
 

Modified: tuscany/sca-cpp/trunk/modules/server/mod-wiring.cpp
URL: http://svn.apache.org/viewvc/tuscany/sca-cpp/trunk/modules/server/mod-wiring.cpp?rev=895165&r1=895164&r2=895165&view=diff
==============================================================================
--- tuscany/sca-cpp/trunk/modules/server/mod-wiring.cpp (original)
+++ tuscany/sca-cpp/trunk/modules/server/mod-wiring.cpp Sat Jan  2 10:27:26 2010
@@ -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 @@
     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 @@
     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 @@
 /**
  * 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 @@
 
     // 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 @@
     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 @@
 
     // 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 @@
     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 @@
  * 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 @@
 /**
  * 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 @@
  * 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 @@
     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 @@
  * 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 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 @@
  * 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 @@
    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);
     }
 }

Modified: tuscany/sca-cpp/trunk/test/store-script/store-script-test.cpp
URL: http://svn.apache.org/viewvc/tuscany/sca-cpp/trunk/test/store-script/store-script-test.cpp?rev=895165&r1=895164&r2=895165&view=diff
==============================================================================
--- tuscany/sca-cpp/trunk/test/store-script/store-script-test.cpp (original)
+++ tuscany/sca-cpp/trunk/test/store-script/store-script-test.cpp Sat Jan  2 10:27:26 2010
@@ -25,12 +25,10 @@
 
 #include <assert.h>
 #include <regex.h>
-#include <iostream>
-#include <fstream>
-#include <string>
+#include "stream.hpp"
+#include "string.hpp"
 #include "list.hpp"
 #include "driver.hpp"
-#include "slist.hpp"
 #include "xml.hpp"
 #include "../json/json.hpp"
 
@@ -38,51 +36,47 @@
 
 using namespace tuscany;
 
-bool contains(const std::string& str, const std::string& pattern) {
-    return str.find(pattern) != std::string::npos;
-}
-
 bool testScript() {
-    std::ifstream is("store-script.scm", std::ios_base::in);
-    std::ostringstream os;
-    eval::evalDriverRun(is, os);
-
-    assert(contains(os.str(), "(\"Sample Feed\" \""));
-    assert(contains(os.str(), "\" (\"Item\" \""));
-    assert(contains(os.str(), "\" ((javaClass \"services.Item\") (name \"Orange\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 3.55))) (\"Item\" \""));
-    assert(contains(os.str(), "\" ((javaClass \"services.Item\") (name \"Apple\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 2.99))))"));
+    gc_scoped_pool pool;
+
+    ifstream is("store-script.scm");
+    ostringstream os;
+    eval::evalDriverRun(is, os, pool);
+    assert(contains(str(os), "(\"Sample Feed\" \""));
+    assert(contains(str(os), "\" (\"Item\" \""));
+    assert(contains(str(os), "\" ((javaClass \"services.Item\") (name \"Orange\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 3.55))) (\"Item\" \""));
+    assert(contains(str(os), "\" ((javaClass \"services.Item\") (name \"Apple\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 2.99))))"));
     return true;
 }
 
 bool testEval() {
     {
-        std::ifstream is("store-script.scm", std::ios_base::in);
-        std::ostringstream os;
+        gc_scoped_pool pool;
+        ifstream is("store-script.scm");
+        ostringstream os;
         eval::setupDisplay(os);
-
-        gc_pool pool;
         eval::Env globalEnv = eval::setupEnvironment(pool);
-        const value exp(mklist<value>("storeui_service", std::string("getcatalog")));
+        const value exp(mklist<value>("storeui_service", string("getcatalog")));
         const value val = eval::evalScript(exp, is, globalEnv, pool);
 
-        std::ostringstream vs;
+        ostringstream vs;
         vs << val;
-        assert(contains(vs.str(), "(((javaClass \"services.Item\") (name \"Apple\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 2.99)) ((javaClass \"services.Item\") (name \"Orange\")
(currencyCode \"USD\") (currencySymbol \"$\") (price 3.55)) ((javaClass \"services.Item\")
(name \"Pear\") (currencyCode \"USD\") (currencySymbol \"$\") (price 1.55)))"));
+        assert(contains(str(vs), "(((javaClass \"services.Item\") (name \"Apple\") (currencyCode
\"USD\") (currencySymbol \"$\") (price 2.99)) ((javaClass \"services.Item\") (name \"Orange\")
(currencyCode \"USD\") (currencySymbol \"$\") (price 3.55)) ((javaClass \"services.Item\")
(name \"Pear\") (currencyCode \"USD\") (currencySymbol \"$\") (price 1.55)))"));
     }
 
     {
-        std::ifstream is("store-script.scm", std::ios_base::in);
-        std::ostringstream os;
+        gc_scoped_pool pool;
+        ifstream is("store-script.scm");
+        ostringstream os;
         eval::setupDisplay(os);
 
-        gc_pool pool;
         eval::Env globalEnv = eval::setupEnvironment(pool);
-        const value exp(mklist<value>("storeui_service", std::string("gettotal")));
+        const value exp(mklist<value>("storeui_service", string("gettotal")));
         const value res = eval::evalScript(exp, is, globalEnv, pool);
 
-        std::ostringstream rs;
+        ostringstream rs;
         rs << res;
-        assert(contains(rs.str(), "10"));
+        assert(contains(str(rs), "10"));
     }
     return true;
 }
@@ -91,12 +85,12 @@
 
 int main() {
 
-    std::cout << "Testing..." << std::endl;
+    tuscany::cout << "Testing..." << tuscany::endl;
 
     store::testScript();
     store::testEval();
 
-    std::cout << "OK" << std::endl;
+    tuscany::cout << "OK" << tuscany::endl;
 
     return 0;
 }



Mime
View raw message