ScXMLEvaluator.h

#ifndef COIN_SCXMLEVALUATOR_H
#define COIN_SCXMLEVALUATOR_H
 
/**************************************************************************\
 * Copyright (c) Kongsberg Oil & Gas Technologies AS
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * 
 * Neither the name of the copyright holder nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\**************************************************************************/
 
#include <Inventor/scxml/ScXMLObject.h>
#include <Inventor/tools/SbLazyPimplPtr.h>
 
class ScXMLDocument;
class ScXMLStateMachine;
class ScXMLDataObj;
 
 
class COIN_DLL_API ScXMLEvaluator : public ScXMLObject {
  typedef ScXMLObject inherited;
  SCXML_OBJECT_ABSTRACT_HEADER(ScXMLEvaluator)
public:
  static void initClass(void);
  static void cleanClass(void);
 
  ScXMLEvaluator(void);
  virtual ~ScXMLEvaluator(void);
 
  virtual void setStateMachine(ScXMLStateMachine * sm);
  ScXMLStateMachine * getStateMachine(void) const { return this->statemachine; }
 
  virtual ScXMLDataObj * evaluate(const char * expression) const = 0;
 
  virtual SbBool setAtLocation(const char * location, ScXMLDataObj * obj) = 0;
  virtual ScXMLDataObj * locate(const char * location) const = 0;
 
  virtual void clearTemporaryVariables(void);
 
protected:
 
private:
  ScXMLStateMachine * statemachine;
 
  class PImpl;
  SbLazyPimplPtr<PImpl> pimpl;
 
}; // ScXMLEvaluator
 
 
// *************************************************************************
 
class COIN_DLL_API ScXMLDataObj : public ScXMLObject {
  SCXML_OBJECT_ABSTRACT_HEADER(ScXMLDataObj)
  typedef ScXMLObject inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  ScXMLDataObj(void);
  virtual ~ScXMLDataObj(void);
 
  void setContainer(ScXMLObject * container);
  ScXMLObject * getContainer(void) const { return this->container; }
 
private:
  ScXMLObject * container;
 
}; // ScXMLDataObj
 
class COIN_DLL_API ScXMLConstantDataObj : public ScXMLDataObj {
  SCXML_OBJECT_ABSTRACT_HEADER(ScXMLConstantDataObj)
  typedef ScXMLDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  virtual ScXMLDataObj * clone(void) const = 0;
  virtual void convertToString(SbString & str) const = 0;
 
};
 
 
class COIN_DLL_API ScXMLStringDataObj : public ScXMLConstantDataObj {
  SCXML_OBJECT_HEADER(ScXMLStringDataObj)
  typedef ScXMLConstantDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(const char * value);
 
  ScXMLStringDataObj(void);
  ScXMLStringDataObj(const char * value);
  virtual ~ScXMLStringDataObj(void);
 
  void setString(const char * value);
  const char * getString(void) const { return this->value; }
 
  virtual ScXMLDataObj * clone(void) const;
  virtual void convertToString(SbString & str) const;
 
private:
  char * value;
 
};
 
 
class COIN_DLL_API ScXMLRealDataObj : public ScXMLConstantDataObj {
  SCXML_OBJECT_HEADER(ScXMLRealDataObj)
  typedef ScXMLConstantDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(double value);
 
  ScXMLRealDataObj(void);
  ScXMLRealDataObj(double value);
  virtual ~ScXMLRealDataObj(void);
 
  void setReal(double value);
  double getReal(void) const { return this->value; }
 
  virtual ScXMLDataObj * clone(void) const;
  virtual void convertToString(SbString & str) const;
 
private:
  double value;
 
};
 
 
class COIN_DLL_API ScXMLBoolDataObj : public ScXMLConstantDataObj {
  SCXML_OBJECT_HEADER(ScXMLBoolDataObj)
  typedef ScXMLConstantDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(SbBool value);
 
  ScXMLBoolDataObj(void);
  ScXMLBoolDataObj(SbBool value);
  virtual ~ScXMLBoolDataObj(void);
 
  void setBool(SbBool value);
  SbBool getBool(void) const { return this->value; }
 
  virtual ScXMLDataObj * clone(void) const;
  virtual void convertToString(SbString & str) const;
 
private:
  SbBool value;
 
};
 
 
class COIN_DLL_API ScXMLSbDataObj : public ScXMLConstantDataObj {
  SCXML_OBJECT_HEADER(ScXMLSbDataObj)
  typedef ScXMLConstantDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(const char * value);
 
  ScXMLSbDataObj(void);
  ScXMLSbDataObj(const char * value);
  virtual ~ScXMLSbDataObj(void);
 
  void setSbValue(const char * value);
  const char * getSbValue(void) const { return this->value; }
 
  virtual ScXMLDataObj * clone(void) const;
  virtual void convertToString(SbString & str) const;
 
private:
  char * value;
 
};
 
 
class COIN_DLL_API ScXMLXMLDataObj : public ScXMLDataObj {
  SCXML_OBJECT_HEADER(ScXMLXMLDataObj)
  typedef ScXMLDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  ScXMLXMLDataObj(void);
  virtual ~ScXMLXMLDataObj(void);
 
  virtual ScXMLDataObj * clone(void) const;
 
};
 
 
class COIN_DLL_API ScXMLExprDataObj : public ScXMLDataObj {
  SCXML_OBJECT_ABSTRACT_HEADER(ScXMLExprDataObj)
  typedef ScXMLDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  ScXMLExprDataObj(void);
  virtual ~ScXMLExprDataObj(void);
 
  ScXMLDataObj * evaluate(ScXMLStateMachine * sm);
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const = 0;
 
private:
  ScXMLDataObj * result;
 
};
 
 
class COIN_DLL_API ScXMLReferenceDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLReferenceDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(const char * reference);
 
  ScXMLReferenceDataObj(void);
  ScXMLReferenceDataObj(const char * reference);
  virtual ~ScXMLReferenceDataObj(void);
 
  void setReference(const char * reference);
  const char * getReference(void) const { return this->reference; }
 
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  char * reference;
 
};
 
 
// *************************************************************************
// logical operators
 
class COIN_DLL_API ScXMLAndOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLAndOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLAndOpExprDataObj(void);
  ScXMLAndOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLAndOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLOrOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLOrOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLOrOpExprDataObj(void);
  ScXMLOrOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLOrOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLNotOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLNotOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * rhs);
 
  ScXMLNotOpExprDataObj(void);
  ScXMLNotOpExprDataObj(ScXMLDataObj * rhs);
  virtual ~ScXMLNotOpExprDataObj(void);
 
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * rhs;
 
};
 
 
class COIN_DLL_API ScXMLEqualsOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLEqualsOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLEqualsOpExprDataObj(void);
  ScXMLEqualsOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLEqualsOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
// *************************************************************************
// arithmetic operators
 
class COIN_DLL_API ScXMLAddOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLAddOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLAddOpExprDataObj(void);
  ScXMLAddOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLAddOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLSubtractOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLSubtractOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLSubtractOpExprDataObj(void);
  ScXMLSubtractOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLSubtractOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLMultiplyOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLMultiplyOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLMultiplyOpExprDataObj(void);
  ScXMLMultiplyOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLMultiplyOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLDivideOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLDivideOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
 
  ScXMLDivideOpExprDataObj(void);
  ScXMLDivideOpExprDataObj(ScXMLDataObj * lhs, ScXMLDataObj * rhs);
  virtual ~ScXMLDivideOpExprDataObj(void);
 
  void setLHS(ScXMLDataObj * lhs);
  const ScXMLDataObj * getLHS(void) const { return this->lhs; }
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * lhs, * rhs;
 
};
 
 
class COIN_DLL_API ScXMLNegateOpExprDataObj : public ScXMLExprDataObj {
  SCXML_OBJECT_HEADER(ScXMLNegateOpExprDataObj)
  typedef ScXMLExprDataObj inherited;
public:
  static void initClass(void);
  static void cleanClass(void);
 
  static ScXMLDataObj * createFor(ScXMLDataObj * rhs);
 
  ScXMLNegateOpExprDataObj(void);
  ScXMLNegateOpExprDataObj(ScXMLDataObj * rhs);
  virtual ~ScXMLNegateOpExprDataObj(void);
 
  void setRHS(ScXMLDataObj * rhs);
  const ScXMLDataObj * getRHS(void) const { return this->rhs; }
 
protected:
  virtual SbBool evaluateNow(ScXMLStateMachine * sm, ScXMLDataObj *& pointer) const;
 
private:
  ScXMLDataObj * rhs;
 
};
 
 
#endif // !COIN_SCXMLEVALUATOR_H