DataObjectPtr BasicPlugin::makeDuplicate() const {
#if 0
BasicPluginPtr plugin = kst_cast<BasicPlugin>(DataObject::createPlugin(propertyString()));
// use same inputs
for (VectorMap::ConstIterator iter = _inputVectors.begin(); iter != _inputVectors.end(); ++iter) {
plugin->inputVectors().insert(iter.key(), iter.value());
}
for (ScalarMap::ConstIterator iter = _inputScalars.begin(); iter != _inputScalars.end(); ++iter) {
plugin->inputScalars().insert(iter.key(), iter.value());
}
for (StringMap::ConstIterator iter = _inputStrings.begin(); iter != _inputStrings.end(); ++iter) {
plugin->inputStrings().insert(iter.key(), iter.value());
}
// create new outputs
for (VectorMap::ConstIterator iter = outputVectors().begin(); iter != outputVectors().end(); ++iter) {
KstWriteLocker blockVectorUpdates(&vectorList.lock());
VectorPtr v = new Vector(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), 0, plugin.data()); // FIXME: unique tag generation
plugin->outputVectors().insert(iter.key(), v);
}
for (ScalarMap::ConstIterator iter = outputScalars().begin(); iter != outputScalars().end(); ++iter) {
ScalarPtr s = new Scalar(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), plugin.data()); // FIXME: unique tag generation
plugin->outputScalars().insert(iter.key(), s);
}
for (StringMap::ConstIterator iter = outputStrings().begin(); iter != outputStrings().end(); ++iter) {
StringPtr s = new String(ObjectTag(iter.value()->tag().tag() + "'", iter.value()->tag().context()), plugin.data()); // FIXME: unique tag generation
plugin->outputStrings().insert(iter.key(), s);
}
// set the same plugin
plugin->setTagName(ObjectTag(tag().tag() + "'", tag().context())); // FIXME: unique tag generation method
map.insert(this, DataObjectPtr(plugin));
return DataObjectPtr(plugin);
#endif
// FIXME: implement this
return 0L;
}
void BasicPlugin::internalUpdate() {
//Make sure we have all the necessary inputs
if (!inputsExist())
return;
writeLockInputsAndOutputs();
//Call the plugins algorithm to operate on the inputs
//and produce the outputs
if ( !algorithm() ) {
Debug::self()->log(i18n("There is an error in the %1 algorithm.").arg(propertyString()), Debug::Error);
unlockInputsAndOutputs();
return;
}
//Perform update on the outputs
updateOutput();
createScalars();
unlockInputsAndOutputs();
return;
}
void KstBasicPlugin::showNewDialog() {
//FIXME shouldn't tagName() == propertyString() ??
KstDialogs::self()->showBasicPluginDialog(propertyString());
}
QString KoListLevelProperties::listItemSuffix() const
{
return propertyString(KoListStyle::ListItemSuffix);
}
/******************************************************************************
Syntax for Modify command is:
MODIFY <jobname>,APPL=CONFIG,<properyname>=['<value>'|<value>][,PLANNED]
VERSION
ENV[,<varname>][=<value>]
Parameter <command> represents the string following the "APPL=" token.
******************************************************************************/
void ZOSConsoleManager::processModifyCommand( char* command )
{
PEG_METHOD_ENTER(TRC_SERVER,
"ZOSConsoleManager::processModifyCommand");
char* currentPtr = command;
char* cmdPtr = NULL;
char* cfgProperty = NULL;
char* cfgValue = NULL;
char* planned = NULL;
Boolean currentValueIsNull = false;
Boolean valueIsQuoted = false;
CommandType consCmd=consoleCmdInvalid;
currentPtr = _skipBlanks(currentPtr);
if (!memcmp(currentPtr,STRLIT_ARGS(ZOSCONSOLEMANAGER_TOKEN_CONFIG)))
{
currentPtr += strlen(ZOSCONSOLEMANAGER_TOKEN_CONFIG);
consCmd = consoleCmdConfig;
}
else if (!memcmp(currentPtr,STRLIT_ARGS(ZOSCONSOLEMANAGER_TOKEN_VERSION)))
{
consCmd = consoleCmdVersion;
_displayServiceLevel();
PEG_METHOD_EXIT();
return;
}
else if (!memcmp(currentPtr,STRLIT_ARGS(ZOSCONSOLEMANAGER_TOKEN_ENV)))
{
consCmd = consoleCmdEnv;
currentPtr += strlen(ZOSCONSOLEMANAGER_TOKEN_ENV);
if (*currentPtr == ',')
{
currentPtr++;
}
}
else
{
_issueSyntaxError(command);
PEG_METHOD_EXIT();
return;
}
// Here currentPtr points after the [CONFIG,|VERSION|ENV] token.
// Following is either the name of a variable or nothing
currentPtr = _skipBlanks(currentPtr);
cfgProperty = currentPtr;
currentPtr = strchr(currentPtr,'=');
if (currentPtr==NULL)
{
if (consCmd == consoleCmdEnv)
{
_showEnvironment(cfgProperty);
PEG_METHOD_EXIT();
return;
}
else
{
_issueSyntaxError(command);
PEG_METHOD_EXIT();
return;
}
}
else
{
// skip the "="
*currentPtr = '\0';
currentPtr++;
currentPtr = _skipBlanks(currentPtr);
if (*currentPtr == '\0' || *currentPtr ==',')
{
currentValueIsNull=true;
}
else if (*currentPtr == '\'')
{
// Check if value is enclosed in quotes
char* temp = strchr(currentPtr+1,'\'');
if (temp!=NULL)
{
// skip the starting "'"
*currentPtr = '\0';
currentPtr++;
cfgValue = currentPtr;
currentPtr = temp;
// skip the ending "'"
*currentPtr = '\0';
currentPtr++;
valueIsQuoted = true;
}
else
{
_issueSyntaxError(command);
PEG_METHOD_EXIT();
return;
}
}
else
{
cfgValue = currentPtr;
}
}
currentPtr = _skipBlanks(currentPtr);
planned = strchr(currentPtr,',');
if (planned!=NULL)
{
*planned = '\0';
planned++;
planned = _skipBlanks(planned);
if (memcmp(planned,STRLIT_ARGS(ZOSCONSOLEMANAGER_TOKEN_PLANNED)))
{
_issueSyntaxError(command);
PEG_METHOD_EXIT();
return;
}
}
_stripTrailingBlanks( cfgProperty );
PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,"Update property: %s", cfgProperty));
if (currentValueIsNull)
{
PEG_TRACE_CSTRING(TRC_SERVER, Tracer::LEVEL4,
"Set property with null value");
}
else
{
_stripTrailingBlanks( cfgValue );
PEG_TRACE((TRC_SERVER, Tracer::LEVEL4,
"Update property value to: %s", cfgValue));
}
if (planned != NULL)
{
PEG_TRACE_CSTRING(TRC_SERVER, Tracer::LEVEL4,
"Updating planned value");
}
if (consCmd == consoleCmdEnv)
{
_updateEnvironment(cfgProperty, cfgValue);
PEG_METHOD_EXIT();
return;
}
String propertyString(cfgProperty);
String propertyValue;
if (!currentValueIsNull)
{
propertyValue.assign(cfgValue);
if (!valueIsQuoted)
{
// All values that were not enclosed in quotes are
// converted to lowercase
propertyValue.toLower();
}
}
_updateConfiguration(propertyString,
propertyValue,
currentValueIsNull,
planned);
PEG_METHOD_EXIT();
}
