diff options
Diffstat (limited to 'sca-cpp/branches/cpp-contrib/contrib/runtime/core/src/tuscany/sca/core/Operation.cpp')
| -rw-r--r-- | sca-cpp/branches/cpp-contrib/contrib/runtime/core/src/tuscany/sca/core/Operation.cpp | 578 |
1 files changed, 578 insertions, 0 deletions
diff --git a/sca-cpp/branches/cpp-contrib/contrib/runtime/core/src/tuscany/sca/core/Operation.cpp b/sca-cpp/branches/cpp-contrib/contrib/runtime/core/src/tuscany/sca/core/Operation.cpp new file mode 100644 index 0000000000..335ed5d369 --- /dev/null +++ b/sca-cpp/branches/cpp-contrib/contrib/runtime/core/src/tuscany/sca/core/Operation.cpp @@ -0,0 +1,578 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#include <stdarg.h> +#include <sstream> + +#include "tuscany/sca/core/Operation.h" +#include "tuscany/sca/util/Logging.h" +#include "tuscany/sca/core/Exceptions.h" +#include "tuscany/sca/core/SCARuntime.h" + +using namespace std; +using namespace commonj::sdo; + + +namespace tuscany +{ + namespace sca + { + // =========== + // Constructor + // =========== + Operation::Operation(const char* operationName) + { + logentry(); + if (operationName != 0) + { + name = operationName; + } + } + + // ========== + // Destructor + // ========== + Operation::~Operation() + { + logentry(); + clean(); + } + + // ========== + // Copy Constructor + // ========== + Operation::Operation(const Operation& op) + { + logentry(); + copy(op); + } + + // ========== + // operator= + // ========== + Operation& Operation::operator=(const Operation& op) + { + logentry(); + if (&op != this) + { + copy(op); + } + return *this; + } + + // ========== + // Clean + // ========== + void Operation::clean() + { + logentry(); + for (unsigned int i = 0; i < getNParms(); i++) + { + const Parameter& parm = getParameter(i); + if (parm.getType() == DATAOBJECT) + { + delete (DataObjectPtr*)parm.getValue(); + } + } + + parameters.empty(); + + if (getReturnType() == DATAOBJECT) + { + delete (DataObjectPtr*)getReturnValue(); + } + } + + // ========== + // Copy + // ========== + void Operation::copy(const Operation& op) + { + logentry(); + clean(); + for (unsigned int i = 0; i < op.getNParms(); i++) + { + const Parameter& parm = op.getParameter(i); + if (parm.getType() == DATAOBJECT) + { + addParameter((const DataObject*)parm.getValue()); + } + else + { + parameters.insert(parameters.end(), parm); + } + } + + if (getReturnType() == DATAOBJECT) + { + setReturnValue((const DataObjectPtr*)op.getReturnValue()); + } + else + { + returnValue = op.returnValue; + } + } + + // ============================================== + // getParameter: return parameter at position pos + // ============================================== + void* Operation::getParameterValue(unsigned int pos) const + { + logentry(); + if (pos < parameters.size()) + { + return parameters[pos].getValue(); + } + + return 0; + } + + // ================================================== + // getParameter: return parameter value based on name + // ================================================== + void* Operation::getParameterValue(const string& name) const + { + logentry(); + try + { + return getParameter(name).getValue(); + } + catch(ServiceInvocationException) + {} + + return 0; + } + + // ====================================================== + // getParameter: return parameter based on index position + // ====================================================== + const Operation::Parameter& Operation::getParameter(unsigned int pos) const + { + logentry(); + if (pos < parameters.size()) + { + return parameters[pos]; + } + + throwException(ServiceInvocationException, "Index out of range"); + } + + // =============================================== + // getParameter: return of parameter based on name + // =============================================== + const Operation::Parameter& Operation::getParameter(const string& name) const + { + logentry(); + for(unsigned int pos=0; pos < parameters.size(); pos++) + { + if(parameters[pos].getName() == name) + { + return parameters[pos]; + } + } + + throwException(ServiceInvocationException, "Parameter name not found"); + } + + + // ============================================================ + // getParameterType: return type of parameter based on position + // ============================================================ + Operation::ParameterType Operation::getParameterType(unsigned int pos) const + { + logentry(); + if (pos < parameters.size()) + { + return parameters[pos].getType(); + } + + return VOID_TYPE; + } + + // ======================================================== + // getParameterType: return type of parameter based on name + // ======================================================== + Operation::ParameterType Operation::getParameterType(const string& name) const + { + logentry(); + try + { + return getParameter(name).getType(); + } + catch(ServiceInvocationException) + {} + + return VOID_TYPE; + } + + const string emptyString = string(); + + // ============================================== + // getParameterName: return name of parameter + // ============================================== + const string& Operation::getParameterName(unsigned int pos) const + { + logentry(); + if (pos < parameters.size()) + { + return parameters[pos].getName(); + } + + return emptyString; + } + + // =========================================== + // addParameter: set parameter at position pos + // =========================================== + void Operation::addParameter(const void *parm) + { + logentry(); + loginfo("Adding operation parameter, type: void, value: %p", parm); + parameters.insert(parameters.end(), Parameter((void*)parm, VOID_TYPE)); + } + + void Operation::addParameter(const bool *parm) + { + logentry(); + loginfo("Adding operation parameter, type: bool, value: %d", (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, BOOL)); + } + + void Operation::addParameter(const short *parm) + { + logentry(); + loginfo("Adding operation parameter, type: short, value: %hd", (short)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, SHORT)); + } + + void Operation::addParameter(const int *parm) + { + logentry(); + loginfo("Adding operation parameter, type: int, value: %d", (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, INT)); + } + + void Operation::addParameter(const long *parm) + { + logentry(); + loginfo("Adding operation parameter, type: long, value: %ld", (long)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, LONG)); + } + + void Operation::addParameter(const unsigned short *parm) + { + logentry(); + loginfo("Adding operation parameter, type: unsigned short, value: %hu", (unsigned short)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, USHORT)); + } + + void Operation::addParameter(const unsigned int *parm) + { + logentry(); + loginfo("Adding operation parameter, type: unsigned int, value: %u", (unsigned int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, UINT)); + } + + void Operation::addParameter(const unsigned long *parm) + { + logentry(); + loginfo("Adding operation parameter, type: unsigned long, value: %lu", (unsigned long)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, ULONG)); + } + + void Operation::addParameter(const float *parm) + { + logentry(); + loginfo("Adding operation parameter, type: float, value: %f", (float)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, FLOAT)); + } + + void Operation::addParameter(const double *parm) + { + logentry(); + loginfo("Adding operation parameter, type: double, value: %lf", (double)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, DOUBLE)); + } + + void Operation::addParameter(const long double *parm) + { + logentry(); + loginfo("Adding operation parameter, type: long double, value: %Lf", (long double)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, LONGDOUBLE)); + } + + void Operation::addParameter(const char* *parm) + { + logentry(); + loginfo("Adding operation parameter, type: char*, value: %s", (const char*)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, CHARS)); + } + + void Operation::addParameter(const char *parm) + { + logentry(); + loginfo("Adding operation parameter, type: char, value: %d", (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, CHAR)); + } + + void Operation::addParameter(const string *parm) + { + logentry(); + loginfo("Adding operation parameter, type: string, value: %s", (const char*)(*parm).c_str()); + parameters.insert(parameters.end(), Parameter((void*)parm, STRING)); + } + + void Operation::addParameter(const DataObjectPtr *parm) + { + logentry(); + ostringstream os; + os << *parm; + loginfo("Adding operation parameter, type: DataObject, value: %s", os.str().c_str()); + parameters.insert(parameters.end(), Parameter((void*)new DataObjectPtr(*parm), DATAOBJECT)); + } + + // ======================================================= + // addParameter: set parameter at position pos with a name + // ======================================================= + void Operation::addParameter(const string& name, const void *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: void, value: %p", name.c_str(), parm); + parameters.insert(parameters.end(), Parameter((void*)parm, VOID_TYPE, (string&) name)); + } + + void Operation::addParameter(const string& name, const bool *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: bool, value: %d", name.c_str(), (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, BOOL, (string&) name)); + } + + void Operation::addParameter(const string& name, const short *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: short, value: %hd", name.c_str(), (short)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, SHORT, (string&) name)); + } + + void Operation::addParameter(const string& name, const int *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: int, value: %d", name.c_str(), (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, INT, (string&) name)); + } + + void Operation::addParameter(const string& name, const long *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: long, value: %ld", name.c_str(), (long)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, LONG, (string&) name)); + } + + void Operation::addParameter(const string& name, const unsigned short *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: unsigned short, value: %hu", (unsigned short)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, USHORT, (string&) name)); + } + + void Operation::addParameter(const string& name, const unsigned int *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: unsigned int, value: %u", name.c_str(), (unsigned int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, UINT, (string&) name)); + } + + void Operation::addParameter(const string& name, const unsigned long *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: unsigned long, value: %lu", name.c_str(), (unsigned long)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, ULONG, (string&) name)); + } + + void Operation::addParameter(const string& name, const float *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: float, value: %f", name.c_str(), (float)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, FLOAT, (string&) name)); + } + + void Operation::addParameter(const string& name, const double *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: double, value: %lf", name.c_str(), (double)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, DOUBLE, (string&) name)); + } + + void Operation::addParameter(const string& name, const long double *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: long double, value: %Lf", name.c_str(), (long double)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, LONGDOUBLE, (string&) name)); + } + + void Operation::addParameter(const string& name, const char* *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: char*, value: %s", name.c_str(), (const char*)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, CHARS, (string&) name)); + } + + void Operation::addParameter(const string& name, const char *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: char, value: %d", name.c_str(), (int)*parm); + parameters.insert(parameters.end(), Parameter((void*)parm, CHAR, (string&) name)); + } + + void Operation::addParameter(const string& name, const string *parm) + { + logentry(); + loginfo("Adding operation parameter, name: %s, type: string, value: %s", name.c_str(), (const char*)(*parm).c_str()); + parameters.insert(parameters.end(), Parameter((void*)parm, STRING, (string&) name)); + } + + void Operation::addParameter(const string& name, const DataObjectPtr *parm) + { + logentry(); + ostringstream os; + os << *parm; + loginfo("Adding operation parameter, name: %s, type: DataObject, value: %s", name.c_str(), os.str().c_str()); + parameters.insert(parameters.end(), Parameter((void*)new DataObjectPtr(*parm), DATAOBJECT, (string&) name)); + } + + Operation::Parameter::Parameter(void* val, Operation::ParameterType typ, const string& nam) + : value(val), type(typ), name(nam) + { + } + + // =========================================== + // setReturnValue + // =========================================== + void Operation::setReturnValue(const void *parm) + { + logentry(); + loginfo("Setting operation return value, type: void, value: %p", parm); + returnValue = Parameter((void*)parm, VOID_TYPE); + } + + void Operation::setReturnValue(const bool *parm) + { + logentry(); + loginfo("Setting operation return value, type: bool, value: %d", (bool)*parm); + returnValue = Parameter((void*)parm, BOOL); + } + + void Operation::setReturnValue(const short *parm) + { + logentry(); + loginfo("Setting operation return value, type: short, value: %h", (short)*parm); + returnValue = Parameter((void*)parm, SHORT); + } + + void Operation::setReturnValue(const int *parm) + { + logentry(); + loginfo("Setting operation return value, type: int, value: %d", (int)*parm); + returnValue = Parameter((void*)parm, INT); + } + + void Operation::setReturnValue(const long *parm) + { + logentry(); + loginfo("Setting operation return value, type: long, value: %l", (long)*parm); + returnValue = Parameter((void*)parm, LONG); + } + + void Operation::setReturnValue(const unsigned short *parm) + { + logentry(); + loginfo("Setting operation return value, type: unsigned short, value: %hu", (unsigned short)*parm); + returnValue = Parameter((void*)parm, USHORT); + } + + void Operation::setReturnValue(const unsigned int *parm) + { + logentry(); + loginfo("Setting operation return value, type: unsigned short, value: %u", (unsigned int)*parm); + returnValue = Parameter((void*)parm, UINT); + } + + void Operation::setReturnValue(const unsigned long *parm) + { + logentry(); + loginfo("Setting operation return value, type: unsigned long, value: %lu", (unsigned long)*parm); + returnValue = Parameter((void*)parm, ULONG); + } + + void Operation::setReturnValue(const float *parm) + { + logentry(); + loginfo("Setting operation return value, type: float, value: %f", (float)*parm); + returnValue = Parameter((void*)parm, FLOAT); + } + + void Operation::setReturnValue(const double *parm) + { + logentry(); + loginfo("Setting operation return value, type: double, value: %lf", (double)*parm); + returnValue = Parameter((void*)parm, DOUBLE); + } + + void Operation::setReturnValue(const long double *parm) + { + logentry(); + loginfo("Setting operation return value, type: long double, value: %Lf", (long double)*parm); + returnValue = Parameter((void*)parm, LONGDOUBLE); + } + + void Operation::setReturnValue(const char *parm) + { + logentry(); + loginfo("Setting operation return value, type: char, value: %d", (char)*parm); + returnValue = Parameter((void*)parm, CHAR); + } + + void Operation::setReturnValue(const char* *parm) + { + logentry(); + loginfo("Setting operation return value, type: char*, value: %s", (char*)*parm); + returnValue = Parameter((void*)parm, CHARS); + } + + void Operation::setReturnValue(const string *parm) + { + logentry(); + loginfo("Setting operation return value, type: string, value: %s", (*parm).c_str()); + returnValue = Parameter((void*)parm, STRING); + } + + void Operation::setReturnValue(const DataObjectPtr *parm) + { + logentry(); + ostringstream os; + os << *parm; + loginfo("Setting operation return value, type: DataObject, value: %s", os.str().c_str()); + returnValue = Parameter((void*)new DataObjectPtr(*parm), DATAOBJECT); + } + + } // End namespace sca +} // End namespace tuscany |