DbEvalGraph.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _DbEvalGraph_h_Included_
#define _DbEvalGraph_h_Included_
 
#include "SmartPtr.h"
#include "DbObject.h"
 
#include "TD_PackPush.h"
 
// Forward class declarations
 
class  OdDbEvalGraph;
class  OdDbEvalEdgeInfo;
class  OdDbEvalExpr;
class  OdDbEvalConnectable;
class  OdDbEvalContext;
class  OdDbEvalContextPair;
class  OdDbEvalContextIterator;
class  OdResBuf;
class  OdDbImpEvalContext;
class  OdDbImpEvalContextIterator;
 
typedef OdSmartPtr<OdDbEvalGraph> OdDbEvalGraphPtr;
 
typedef OdSmartPtr<OdDbEvalContextIterator> OdDbEvalContextIteratorPtr;
 
typedef OdSmartPtr<OdDbEvalExpr> OdDbEvalExprPtr;
 
typedef unsigned long OdDbEvalNodeId;
 
typedef OdArray<OdDbEvalNodeId, OdMemoryAllocator<OdDbEvalNodeId> > OdDbEvalNodeIdArray;
typedef OdArray<OdDbEvalEdgeInfo> OdDbEvalEdgeInfoArray;
typedef OdArray<OdDbEvalExprPtr> OdDbEvalExprPtrArray;
typedef OdArray<OdResBufPtr> OdResBufArray;
 
#include "OdPlatformSettings.h"
#include "StringArray.h"
 
#ifdef DYNBLOCKS_DLL_EXPORTS
#ifndef SWIG
#define DYNBLOCKS_EXPORT        OD_TOOLKIT_EXPORT
#else
#define DYNBLOCKS_EXPORT        
#endif
#define DYNBLOCKS_EXPORT_STATIC OD_STATIC_EXPORT
#else       
#ifndef SWIG
#define DYNBLOCKS_EXPORT        OD_TOOLKIT_IMPORT
#else
#define DYNBLOCKS_EXPORT        
#endif
#define DYNBLOCKS_EXPORT_STATIC OD_STATIC_IMPORT
#endif
 
class OdDbEvalIdMap
{
public:
  virtual ~OdDbEvalIdMap() {};
 
  virtual OdDbEvalNodeId find(const OdDbEvalNodeId& key) = 0;
 
  virtual void kill() = 0;
};
 
 
class DYNBLOCKS_EXPORT OdDbEvalGraph : public OdDbObject
{
public:
 
  enum NodeId {
    kNullNodeId = 0
  };
 
  ODDB_DECLARE_MEMBERS(OdDbEvalGraph);
 
  OdDbEvalGraph();
  virtual ~OdDbEvalGraph();
 
  /* Management */
 
  static bool hasGraph(const OdDbObject* pObj,
    const OdString& key);
 
  static OdDbEvalGraphPtr getGraph(const OdDbObject* pObj,
    const OdString& pKey,
    const OdDb::OpenMode openMode = OdDb::kForRead );
 
 
  static bool createGraph(OdDbObject* pObj,
    const OdString& key);
 
 
  static bool removeGraph(OdDbObject* pObj,
    const OdString& pKey);
 
  static bool hasGraph(OdDbDatabase* pDb,
    const OdString& key);
 
  static OdDbEvalGraphPtr getGraph(OdDbDatabase* pDb,
    const OdString& key,
    const OdDb::OpenMode openMode = OdDb::kForRead );
 
  static bool createGraph(OdDbDatabase* pDb,
    const OdString& key);
 
  static bool removeGraph(OdDbDatabase* pDb,
    const OdString& key);
 
  virtual OdDbEvalNodeId addNode(OdDbEvalExpr* pNode);
 
  virtual bool removeNode  (const OdDbEvalNodeId& nodeId);
 
  virtual bool removeNode (OdDbEvalExpr* pNode);
 
  virtual void getAllNodes (OdDbEvalNodeIdArray& allNodes) const;
 
  virtual OdDbEvalExprPtr getNode( const OdDbEvalNodeId& nodeId, OdDb::OpenMode openMode = OdDb::kForRead ) const;
 
 
  virtual bool addEdge(const OdDbEvalNodeId& idFrom,
    const OdDbEvalNodeId& idTo);
 
  virtual bool addEdge(const OdDbEvalNodeId& idFrom,
    const OdDbEvalNodeId& idTo,
    bool  invertible);
 
 
  virtual bool removeEdge(const OdDbEvalNodeId& idFrom,
    const OdDbEvalNodeId& idTo);
 
  virtual void getIncomingEdges(const OdDbEvalNodeId& nodeId,
    OdDbEvalEdgeInfoArray& edges) const;
 
  virtual void getOutgoingEdges(const OdDbEvalNodeId& nodeId,
    OdDbEvalEdgeInfoArray& edges) const;
 
 
  virtual bool getEdgeInfo(const OdDbEvalNodeId& idFrom,
    const OdDbEvalNodeId& idTo, OdDbEvalEdgeInfo& edgeInfo) const;
 
 
  virtual void addGraph(OdDbEvalGraph* pGraphToAdd, OdDbEvalIdMap*& idMap);
 
  /* Evaluation */
 
  virtual bool evaluate() const;
 
  virtual bool evaluate(
    const OdDbEvalContext* pContext) const;
 
  virtual bool evaluate(
    const OdDbEvalContext* pContext,
    const OdDbEvalNodeIdArray* pActivateNodes) const;
 
 
  virtual bool activate(
    const OdDbEvalNodeIdArray& activatedNodes) const;
 
 
  virtual bool activate(
    const OdDbEvalNodeIdArray& activatedNodes,
    OdDbEvalNodeIdArray* pActiveSubgraph) const;
 
  virtual bool activate(
    const OdDbEvalNodeIdArray& activatedNodes,
    OdDbEvalNodeIdArray* pActiveSubgraph,
    OdDbEvalNodeIdArray* pCycleNodes) const;
 
 
  virtual bool getIsActive(const OdDbEvalNodeId& nodeId,
    bool& isActive) const;
 
  virtual bool equals(const OdDbEvalGraph* pOther) const;
 
 
  virtual bool isSubgraphOf(const OdDbEvalGraph* pOther) const;
 
  virtual OdResult dwgInFields(OdDbDwgFiler* pFiler) ODRX_OVERRIDE;
  virtual void dwgOutFields(OdDbDwgFiler* pFiler) const ODRX_OVERRIDE;
  virtual OdResult dxfInFields(OdDbDxfFiler* pFiler) ODRX_OVERRIDE;
  virtual void dxfOutFields(OdDbDxfFiler* pFiler) const ODRX_OVERRIDE;
  virtual void applyPartialUndo(OdDbDwgFiler* pFiler, OdRxClass* pClassObj) ODRX_OVERRIDE;
  virtual void copyFrom(const OdRxObject* p) ODRX_OVERRIDE;
  virtual OdResult postInDatabase(OdDbDatabase*);
  virtual void subHandOverTo(
    OdDbObject* pNewObject) ODRX_OVERRIDE;
};
 
 
class DYNBLOCKS_EXPORT OdDbEvalEdgeInfo
{
public:
  OdDbEvalEdgeInfo()
    : mFlags(0), mRefCount(0)
  {
    mIdFrom = OdDbEvalGraph::kNullNodeId;
    mIdTo = OdDbEvalGraph::kNullNodeId;
  }
 
  OdDbEvalEdgeInfo(OdDbEvalNodeId fromId,
    OdDbEvalNodeId toId,
    long           flags,
    unsigned long  count)
    : mIdFrom(fromId), mIdTo(toId), mFlags(flags), mRefCount(count)
  {}
 
  OdDbEvalNodeId from () const;
 
  OdDbEvalNodeId to () const;
  unsigned long refCount() const;
 
  bool isInvertible () const;
  bool isSuppressed  () const;
 
  bool operator == (const OdDbEvalEdgeInfo& other) const;
 
private:
  OdDbEvalNodeId mIdFrom;
  OdDbEvalNodeId mIdTo;
  long mFlags;
  unsigned long mRefCount;
};
 
 
class DYNBLOCKS_EXPORT OdDbEvalExpr : public OdDbObject
{
public:
  ODDB_DECLARE_MEMBERS(OdDbEvalExpr);
 
  OdDbEvalExpr();
  virtual ~OdDbEvalExpr();
 
  OdDbEvalGraphPtr getGraph( OdDb::OpenMode openMode = OdDb::kForRead ) const;
 
  OdDbEvalNodeId nodeId() const;
 
  virtual void addedToGraph (OdDbEvalGraph* pGraph);
 
  virtual void removedFromGraph (OdDbEvalGraph* pGraph);
 
 
  virtual void adjacentNodeRemoved (const OdDbEvalNodeId& adjNodeId);
 
 
  virtual void adjacentEdgeRemoved (const OdDbEvalNodeId& adjEdgeNodeId);
 
 
  virtual void adjacentEdgeAdded (const OdDbEvalNodeId& fromId,
    const OdDbEvalNodeId& toId,
    bool isInvertible);
 
 
  virtual void movedFromGraph (OdDbEvalGraph* pFromGraph);
 
  virtual void movedIntoGraph (OdDbEvalGraph* pIntoGraph);
 
 
 
  virtual void copiedIntoGraph(OdDbEvalGraph* pIntoGraph);
 
  virtual bool isActivatable  () const;
 
  virtual void activated           (OdDbEvalNodeIdArray& argumentActiveList);
 
  virtual void graphEvalStart (bool nodeIsActive);
 
 
  virtual void graphEvalEnd(bool nodeIsActive);
 
  virtual void graphEvalAbort(bool nodeIsActive);
 
  virtual bool evaluate(const OdDbEvalContext* evalContext);
 
  virtual bool equals(const OdDbEvalExpr* pOther) const;
 
  OdResBufPtr value() const;
 
  virtual void remappedNodeIds(
    OdDbEvalIdMap& idMap
  );
 
 
  OdResult dwgInFields(OdDbDwgFiler* pFiler);
  void dwgOutFields(OdDbDwgFiler* pFiler) const;
  OdResult dxfInFields(OdDbDxfFiler* pFiler);
  void dxfOutFields(OdDbDxfFiler* pFiler) const;
  virtual OdResult postInDatabase(OdDbDatabase*);
 
protected:
 
  OdResBufPtr m_lastValue;
  friend class OdDbEvalExprImpl;
};
 
 
class DYNBLOCKS_EXPORT OdDbEvalConnectable : public OdDbEvalExpr
{
public:
  ODDB_DECLARE_MEMBERS(OdDbEvalConnectable);
 
  virtual ~OdDbEvalConnectable();
 
  virtual void getConnectionNames (OdStringArray& connectionNames) const;
 
  virtual bool hasConnectionNamed (const OdString& connectionName) const;
 
 
  virtual bool getConnectionType  (
    const OdString& connectionName,
    OdResBuf::ValueType& connectionType) const;
 
 
  virtual OdResBufPtr getConnectionValue( const OdString& connectionName) const;
 
 
  virtual bool setConnectionValue ( const OdString& connectionName, const OdResBuf* pValue);
 
 
  virtual bool connectTo (
    const OdString&      thisConnectionName,
    OdDbEvalNodeId sourceConnectableId,
    const OdString&      sourceConnectionName);
 
 
  virtual bool disconnectFrom (
    const OdString&      thisConnectionName,
    OdDbEvalNodeId sourceConnectableId,
    const OdString&      sourceConnectionName);
 
  virtual bool connectionAllowed (
    const OdString&      thisConnectionName,
    OdDbEvalNodeId sourceConnectableId,
    const OdString&      sourceConnectionName) const;
 
 
  virtual bool getConnectedObjects (
    const OdString&      thisConnectionName,
    OdDbEvalNodeIdArray& connectedObjects) const;
 
  virtual bool getConnectedNames (
    const OdString&      thisConnectionName,
    OdDbEvalNodeId sourceConnectableId,
    OdStringArray&       sourceConnectionNames) const;
protected:
 
  OdDbEvalConnectable();
};
 
typedef OdSmartPtr<OdDbEvalConnectable> OdDbEvalConnectablePtr;
 
class DYNBLOCKS_EXPORT OdDbEvalContext : public OdRxObject
{
public:
 
  OdDbEvalContext();
 
 
  virtual ~OdDbEvalContext();
 
  ODRX_DECLARE_MEMBERS(OdDbEvalContext);
 
 
  virtual void insertAt (const OdDbEvalContextPair& pair);
 
 
  virtual void removeAt (const OdString& key);
 
 
  virtual bool getAt (OdDbEvalContextPair& pair) const;
 
 
  virtual OdDbEvalContextIteratorPtr newIterator() const;
 
private:
  OdDbImpEvalContext* m_pImp;
  friend class OdDbImpEvalContextIterator;
};
 
class DYNBLOCKS_EXPORT OdDbEvalContextPair
{
public:
 
  OdDbEvalContextPair();
 
  OdDbEvalContextPair(const OdString& key, void *value);
 
  virtual ~OdDbEvalContextPair();
 
  void setKey (const OdString& key);
 
  const OdString key () const;
 
  void setValue (void* value);
 
  void*       value    () const;
 
private:
  OdString mKey;
  void* mValue;
};
 
 
class DYNBLOCKS_EXPORT OdDbEvalContextIterator : public OdRxObject
{
public:
  OdDbEvalContextIterator();
 
  virtual ~OdDbEvalContextIterator();
 
  ODRX_DECLARE_MEMBERS(OdDbEvalContextIterator);
 
  virtual void start();
 
  virtual bool   next();
 
  virtual bool   done() const;
 
  virtual OdDbEvalContextPair contextPair() const;
 
private:
  OdDbImpEvalContextIterator* m_pImp;
  friend class OdDbImpEvalContext;
};
 
#include "TD_PackPop.h"
 
#endif