XObjectTreeSynchronizer.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : XObjectTreeSynchronizer
 * Package    : Zeus.ZeusBase.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
 *   GNU Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef XObjectTreeSynchronizerH
#define XObjectTreeSynchronizerH

#include <zeusbase/System/Interfaces/IXObject.hpp>
#include <zeusbase/System/Interfaces/IXSynchronAction.hpp>
#include <zeusbase/System/ZObject.h>
#include <zeusbase/System/StringMap.hpp>
#include <zeusbase/System/SingleLinkedList.hpp>

BEGIN_NAMESPACE_Zeus

class TXSynchronAction;
class IXSynchronActionListener;

/****************************************************************************/
/****************************************************************************/
zeusbase_class TXObjectTreeSynchronizer : public TZObject
{
  public:
    TXObjectTreeSynchronizer();

    Retval synchronizeTree(IXObject& rSource, IXObject& rTarget);
    Retval getRootAction(IXSynchronAction*& rpObject);
    Retval getSubAction(IXObject* pRefObject, IXSynchronAction*& rpObject);

    Retval executeRootAction(IXSynchronActionListener* pListener = NULL);
    Retval executeSubAction(IXObject* pRefObject, IXSynchronActionListener* pListener = NULL);

    void setUnfreezeFlag(bool bUnfreeze);
    void setCleanTreeFlag(bool bClean);
    void setForceChangeActions(bool bForceChanges);
    void setNumberOfCycles(Int iCycleCount);
    void setAutoCheck(bool bValue);

    void MQUALIFIER reset();

  protected:
    virtual ~TXObjectTreeSynchronizer();

  private:
    IXObject* m_pSourceTree;
    IXObject* m_pTargetTree;
    IXSynchronAction* m_pActionTree;
    bool m_bUnfreeze;
    bool m_bCleanTree;
    bool m_bForceChanges;
    bool m_bAutoCheckNodes;
    Int m_iCycleCount;



    /*************************************************************************/
    /*************************************************************************/
    struct TypDataRecord
    {
      TString strKey;
      IXObject* pObject;

      TypDataRecord()
      {
        pObject = NULL;
      }

      TypDataRecord(const TString& rName, IXObject& rObject)
      {
        strKey = rName;
        pObject = &rObject;
      }

      bool operator==(const TypDataRecord& rInPar) const
      {
        return (strKey == rInPar.strKey &&
                pObject == rInPar.pObject);
      }

    };

    void releaseInstances();
    void fillMapWithChildObjects(IXObject& rParent, TStringMap<IXObject*>& rMapChildren);
    void fillListWithChildObjects(IXObject& rParent, TSingleLinkedList<TypDataRecord>& rChildren);
    void synchronizeTree_internal(IXObject* pSource, IXObject* pTarget, IXSynchronAction& rAction);
    Retval checkForChanges(IXObject* pSource, IXObject* pTarget, IXSynchronAction& rAction, IXSynchronAction*& rpChildAction);
    TString generateKeyName(IXObject& rObject);
};


//inline methods
/****************************************************************************/
/****************************************************************************/
inline void TXObjectTreeSynchronizer::setUnfreezeFlag(bool bUnfreeze)
{
  m_bUnfreeze = bUnfreeze;
}

/****************************************************************************/
/****************************************************************************/
inline void TXObjectTreeSynchronizer::setCleanTreeFlag(bool bClean)
{
  m_bCleanTree = bClean;
}

/****************************************************************************/
/****************************************************************************/
inline void TXObjectTreeSynchronizer::setForceChangeActions(bool bForceChanges)
{
  m_bForceChanges = bForceChanges;
}

/****************************************************************************/
/****************************************************************************/
inline void TXObjectTreeSynchronizer::setAutoCheck(bool bValue)
{
  m_bAutoCheckNodes = bValue;
}

/****************************************************************************/
/****************************************************************************/
inline void MQUALIFIER TXObjectTreeSynchronizer::reset()
{
  releaseInstances();
}


/****************************************************************************/
/****************************************************************************/
inline void TXObjectTreeSynchronizer::setNumberOfCycles(Int iCycleCount)
{
  m_iCycleCount = iCycleCount;
}

/****************************************************************************/
/****************************************************************************/
inline TString TXObjectTreeSynchronizer::generateKeyName(IXObject& rObject)
{
  TString strName;
  TString strClassName;
  TString strID((long)rObject.getID());
  rObject.getName(strName);
  rObject.getClassName(strClassName);

  TString strKey;
  strKey.concatStr(strName);
  strKey.concat(L"[");
  strKey.concatStr(strID);
  strKey.concat(L"]");
  strKey.concat(L"::");
  strKey.concatStr(strClassName);

  return strKey;
}


END_NAMESPACE_Zeus

#endif