mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
344 lines
9.7 KiB
C++
344 lines
9.7 KiB
C++
/*=========================================================================
|
|
|
|
Program: ParaView
|
|
Module: vtkCommandOptionsXMLParser.cxx
|
|
|
|
Copyright (c) Kitware, Inc.
|
|
All rights reserved.
|
|
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notice for more information.
|
|
|
|
=========================================================================*/
|
|
#include "vtkCommandOptionsXMLParser.h"
|
|
#include "vtkCommandOptions.h"
|
|
#include "vtkObjectFactory.h"
|
|
#include <map>
|
|
#include "vtkStdString.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
struct vtkCommandOptionsXMLParserArgumentStructure
|
|
{
|
|
enum Type { INT_TYPE, BOOL_TYPE, CHAR_TYPE };
|
|
void* Variable;
|
|
int VariableType;
|
|
int ProcessType;
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
//****************************************************************************
|
|
class vtkCommandOptionsXMLParserInternal
|
|
{
|
|
public:
|
|
vtkCommandOptionsXMLParserInternal()
|
|
{
|
|
this->ProcessType = 0;
|
|
}
|
|
|
|
void AddArgument(
|
|
const char* arg,
|
|
vtkCommandOptionsXMLParserArgumentStructure::Type type,
|
|
void* var,
|
|
int ptype);
|
|
int SetArgument(const char* arg, const char* value);
|
|
int GetArgumentProcessType(const char* arg)
|
|
{
|
|
if(this->ArgumentToVariableMap.count(arg) == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
return this->ArgumentToVariableMap[arg].ProcessType;
|
|
}
|
|
std::map<std::string, vtkCommandOptionsXMLParserArgumentStructure> ArgumentToVariableMap;
|
|
int ProcessType;
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::SetProcessTypeInt(int ptype)
|
|
{
|
|
this->Internals->ProcessType = ptype;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::SetProcessType(const char* ptype)
|
|
{
|
|
if(!ptype)
|
|
{
|
|
this->SetProcessTypeInt(vtkCommandOptions::EVERYBODY);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int vtkCommandOptionsXMLParserInternal::SetArgument(const char* arg, const char* value)
|
|
{
|
|
if(this->ArgumentToVariableMap.count(arg))
|
|
{
|
|
vtkCommandOptionsXMLParserArgumentStructure tmp =
|
|
this->ArgumentToVariableMap[arg];
|
|
if(!(tmp.ProcessType & this->ProcessType ||
|
|
tmp.ProcessType == vtkCommandOptions::EVERYBODY ||
|
|
this->ProcessType == vtkCommandOptions::EVERYBODY))
|
|
{
|
|
// Silently skip argument in xml because the process type does not match
|
|
return 1;
|
|
}
|
|
switch(tmp.VariableType)
|
|
{
|
|
case vtkCommandOptionsXMLParserArgumentStructure::BOOL_TYPE:
|
|
{
|
|
int* variable = (int*)tmp.Variable;
|
|
*variable = 1;
|
|
}
|
|
break;
|
|
case vtkCommandOptionsXMLParserArgumentStructure::INT_TYPE:
|
|
{
|
|
if(!value)
|
|
{
|
|
vtkGenericWarningMacro("Bad XML Format missing Value for Name=\""
|
|
<< arg << "\"");
|
|
return 0;
|
|
}
|
|
int* variable = (int*)tmp.Variable;
|
|
*variable = atoi(value);
|
|
}
|
|
break;
|
|
case vtkCommandOptionsXMLParserArgumentStructure::CHAR_TYPE:
|
|
{
|
|
if(!value)
|
|
{
|
|
vtkGenericWarningMacro("Bad XML Format missing Value for Name=\""
|
|
<< arg << "\"");
|
|
return 0;
|
|
}
|
|
char** variable = static_cast<char**>(tmp.Variable);
|
|
if(*variable)
|
|
{
|
|
delete [] *variable;
|
|
*variable = 0;
|
|
}
|
|
*variable = strcpy(new char[strlen(value)+1], value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vtkGenericWarningMacro("Bad XML Format Unknown Option " << arg );
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParserInternal::AddArgument(
|
|
const char* arg,
|
|
vtkCommandOptionsXMLParserArgumentStructure::Type type,
|
|
void* var,
|
|
int ptype)
|
|
{
|
|
if(strlen(arg) < 3)
|
|
{
|
|
vtkGenericWarningMacro(
|
|
"AddArgument must take arguments of the form --foo. "
|
|
"Argument not added: " << arg );
|
|
return;
|
|
}
|
|
vtkCommandOptionsXMLParserArgumentStructure vardata;
|
|
vardata.VariableType = type;
|
|
vardata.Variable = var;
|
|
vardata.ProcessType = ptype;
|
|
this->ArgumentToVariableMap[std::string(arg+2)] = vardata;
|
|
}
|
|
|
|
//****************************************************************************
|
|
//----------------------------------------------------------------------------
|
|
|
|
//----------------------------------------------------------------------------
|
|
vtkStandardNewMacro(vtkCommandOptionsXMLParser);
|
|
|
|
//----------------------------------------------------------------------------
|
|
vtkCommandOptionsXMLParser::vtkCommandOptionsXMLParser()
|
|
{
|
|
this->InPVXTag = 0;
|
|
this->PVOptions = 0;
|
|
this->Internals = new vtkCommandOptionsXMLParserInternal;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
vtkCommandOptionsXMLParser::~vtkCommandOptionsXMLParser()
|
|
{
|
|
delete this->Internals;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::StartElement(const char* name,
|
|
const char** atts)
|
|
{
|
|
if(strcmp(name, "pvx") == 0)
|
|
{
|
|
this->InPVXTag = 1;
|
|
return;
|
|
}
|
|
if(!this->InPVXTag)
|
|
{
|
|
vtkErrorMacro("Bad XML Element found not in <pvx></pvx> tag: " << name);
|
|
return;
|
|
}
|
|
if(strcmp(name, "Option") == 0)
|
|
{
|
|
// check to see if the Named Option Name=option
|
|
// is valid for this type of process. Each argument
|
|
// has a number of processes that it is valid for.
|
|
if(atts && atts[0] && atts[1])
|
|
{
|
|
if(strcmp(atts[0],"Name") == 0)
|
|
{
|
|
int type = this->Internals->GetArgumentProcessType(atts[1]);
|
|
if(!(type & this->PVOptions->GetProcessType() ||
|
|
type == vtkCommandOptions::EVERYBODY) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
this->HandleOption(atts);
|
|
return;
|
|
}
|
|
if(strcmp(name, "Process") == 0)
|
|
{
|
|
this->HandleProcessType(atts);
|
|
return;
|
|
}
|
|
this->PVOptions->ParseExtraXMLTag(name, atts);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::HandleProcessType(const char** atts)
|
|
{
|
|
if(!atts[0] && strcmp(atts[0], "Type"))
|
|
{
|
|
vtkErrorMacro("Bad XML Format 0 attributes found in Process Type, expected Process Type=\"..\" ");
|
|
return;
|
|
}
|
|
if(!atts[1])
|
|
{
|
|
vtkErrorMacro("Bad XML Format 1 attributes found in Process Process Type=\"..\" ");
|
|
return;
|
|
}
|
|
this->SetProcessType(atts[1]);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::HandleOption(const char** atts)
|
|
{
|
|
// atts should be { "Name", "somename", "Value", "somevalue" }
|
|
// The Value is optional as it may be a boolean option
|
|
const char* nameTag = atts[0];
|
|
const char* name = 0;
|
|
// make sure there is a Name=
|
|
if(!nameTag || (strcmp(nameTag, "Name") != 0))
|
|
{
|
|
vtkErrorMacro("Bad XML Format 0 attributes found in Option, expected Name=\"..\" [Value=\"...\"]");
|
|
return;
|
|
}
|
|
// Set name to be the next attribute
|
|
name = atts[1];
|
|
// make sure Name=somthing
|
|
if(!name)
|
|
{
|
|
vtkErrorMacro("Bad XML Format, Name has no name.");
|
|
return;
|
|
}
|
|
|
|
// Now look for Value tag
|
|
const char* valueTag = atts[2];
|
|
const char* value = 0;
|
|
// if there is a value tag and it is "Vaule"
|
|
if(valueTag && (strcmp(valueTag, "Value") != 0))
|
|
{
|
|
vtkErrorMacro("Bad XML Format missing value tag");
|
|
return;
|
|
}
|
|
else if (valueTag)
|
|
{
|
|
if (atts[3])
|
|
{
|
|
value = atts[3];
|
|
}
|
|
else
|
|
{
|
|
vtkErrorMacro("Bad XML Format missing value tag present but no value");
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
this->Internals->SetArgument(name, value);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::EndElement(const char* name)
|
|
{
|
|
if(strcmp(name, "pvx") == 0)
|
|
{
|
|
this->InPVXTag = 0;
|
|
return;
|
|
}
|
|
if(strcmp(name, "Process") == 0)
|
|
{
|
|
this->Internals->ProcessType = 0;
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::AddBooleanArgument(const char* longarg,
|
|
int* var,
|
|
int type)
|
|
{
|
|
this->Internals->AddArgument(
|
|
longarg,
|
|
vtkCommandOptionsXMLParserArgumentStructure::BOOL_TYPE,
|
|
var,
|
|
type);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::AddArgument(const char* longarg,
|
|
int* var,
|
|
int type)
|
|
{
|
|
this->Internals->AddArgument(
|
|
longarg,
|
|
vtkCommandOptionsXMLParserArgumentStructure::INT_TYPE,
|
|
var,
|
|
type);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::AddArgument(const char* longarg,
|
|
char** var,
|
|
int type)
|
|
{
|
|
this->Internals->AddArgument(
|
|
longarg,
|
|
vtkCommandOptionsXMLParserArgumentStructure::CHAR_TYPE,
|
|
var,
|
|
type);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void vtkCommandOptionsXMLParser::PrintSelf(ostream& os, vtkIndent indent)
|
|
{
|
|
this->Superclass::PrintSelf(os, indent);
|
|
}
|