CLRenderFlattener Class Reference

#include <CLRenderFlattener.h>

Static Public Member Functions
static CLGlobalRenderInformation *	flatten_render_information (const CLGlobalRenderInformation &globalRenderInformation, const CCopasiVector< CLGlobalRenderInformation > &globalList) throw (CLUnresolvedReferenceException)
static CLLocalRenderInformation *	flatten_render_information (const CLLocalRenderInformation &localRenderInformation, const CCopasiVector< CLLocalRenderInformation > &localList, const CCopasiVector< CLGlobalRenderInformation > &globalList) throw (CLUnresolvedReferenceException)

Static Protected Member Functions
static CLLocalStyle *	convertGlobalToLocalStyle (const CLGlobalStyle *pGlobal)
static CLRenderInformationBase *	flatten (const CLRenderInformationBase &renderInformation, const CCopasiVector< CLGlobalRenderInformation > &globalList, const CCopasiVector< CLLocalRenderInformation > &localList=CCopasiVector< CLLocalRenderInformation >()) throw (CLUnresolvedReferenceException)

Detailed Description

Definition at line 31 of file CLRenderFlattener.h.

Member Function Documentation

CLLocalStyle * CLRenderFlattener::convertGlobalToLocalStyle ( const CLGlobalStyle *  pGlobal )

staticprotected

Method takes a global style object and converts it to a local style object. The caller is responsible for freeing the memory of the returned object once it is no longer needed.

Definition at line 414 of file CLRenderFlattener.cpp.

References CLStyle::getGroup(), CCopasiObject::getObjectName(), CLStyle::getRoleList(), CLStyle::getTypeList(), pResult, CLStyle::setGroup(), CCopasiObject::setObjectName(), CLStyle::setRoleList(), and CLStyle::setTypeList().

{
  CLLocalStyle* pResult = new CLLocalStyle();
  // we need to copy  all elements from Style
  // mGroup, mRoleList, mTypeList
  pResult->setGroup(pGlobal->getGroup());
  pResult->setRoleList(pGlobal->getRoleList());
  pResult->setTypeList(pGlobal->getTypeList());
  // we need to copy all elements from SBase
  // for our purposes here, all we need is the name and the id
  //pResult->setId(pGlobal->getKey());
  pResult->setObjectName(pGlobal->getObjectName());
  return pResult;
}

CLRenderInformationBase * CLRenderFlattener::flatten ( const CLRenderInformationBase &  renderInformation, const CCopasiVector< CLGlobalRenderInformation > &  globalList, const CCopasiVector< CLLocalRenderInformation > &  localList = CCopasiVector<CLLocalRenderInformation>()  ) throw ( CLUnresolvedReferenceException )

staticprotected

Takes a reference to any type of render information and two lists. The first list is a list of global render information objects, the second list is a list of local render information objects. If the object that is passed in is a global render information object, the second list is not considered.

Definition at line 60 of file CLRenderFlattener.cpp.

References CLRenderInformationBase::addColorDefinition(), CLRenderInformationBase::addGradientDefinition(), CLRenderInformationBase::addLineEnding(), CCopasiMessage::EXCEPTION, CLLineEnding::getId(), CLGradientBase::getId(), CLColorDefinition::getId(), CLLocalStyle::getKeyList(), CLLocalRenderInformation::getListOfStyles(), CLGlobalRenderInformation::getListOfStyles(), CLRenderInformationBase::getReferenceRenderInformationKey(), CLStyle::getRoleList(), CLLocalRenderInformation::getStyle(), CLGlobalRenderInformation::getStyle(), CLStyle::getTypeList(), pResult, CLRenderInformationBase::setBackgroundColor(), and CCopasiVector< T >::size().

Referenced by flatten_render_information().

{
  CLRenderInformationBase* pResult = NULL;

  // the result should be of the same type as the type that is passed in
  bool local = dynamic_cast<const CLLocalRenderInformation*>(&renderInformation) != NULL;


  // create a list of referenced render information objects
  std::vector< const CLRenderInformationBase * > referenceChain;
  const CLRenderInformationBase* pCurrent = &renderInformation;
  const CLRenderInformationBase* pNext = NULL;

  while (pCurrent != NULL)
    {
      // check for reference loops in reference chain
      if (std::find(referenceChain.begin(), referenceChain.end(), pCurrent) != referenceChain.end())
        {
          // we have a loop
          CCopasiMessage(CCopasiMessage::EXCEPTION, "Fatal Error. Found a loop in the referenceRenderInformation attribute chain of the render information");
        }

      referenceChain.push_back(pCurrent);
      std::string referenceKey = pCurrent->getReferenceRenderInformationKey();

      // search the local list if we are dealing with local render information
      if (!referenceKey.empty())
        {
          if (local && localList.size() != 0)
            {
              size_t j = 0, jMax = localList.size();

              while (j < jMax)
                {
                  if (localList[j]->getKey() == referenceKey)
                    {
                      pNext = dynamic_cast<const CLRenderInformationBase*>(localList[j]);
                      break;
                    }

                  ++j;
                }
            }

          // search the global list if necessary
          if (!pNext && globalList.size() != 0)
            {
              size_t j = 0, jMax = globalList.size();

              while (j < jMax)
                {
                  if (globalList[j]->getKey() == referenceKey)
                    {
                      pNext = dynamic_cast<const CLRenderInformationBase*>(globalList[j]);
                      break;
                    }

                  ++j;
                }
            }

          // make sure, we actually find the referenced render information
          if (pNext)
            {
              pCurrent = pNext;
              pNext = NULL;
            }
          else
            {
              throw CLUnresolvedReferenceException(referenceKey);
            }
        }
      else
        {
          // we are at the end
          pCurrent = NULL;
        }
    }

  // no we have to create a flattened version of the list.
  std::map<std::string, const CLStyle*> keyMap;
  std::map<std::string, const CLStyle*> typeMap;
  std::map<std::string, const CLStyle*> roleMap;
  std::map<std::string, const CLColorDefinition*> colors;
  std::map<std::string, const CLLineEnding*> lineEndings;
  std::map<std::string, const CLGradientBase*> gradients;
  std::vector< const CLRenderInformationBase * >::const_iterator it = referenceChain.begin(), endit = referenceChain.end();
  size_t i, iMax;
  const CLColorDefinition* pColorDefinition = NULL;
  const CLGradientBase* pGradientBase = NULL;
  const CLLineEnding* pLineEnding = NULL;

  while (it != endit)
    {
      // go through all styles in the current render information
      // and add each style to one or more maps, depending on whether it
      // specifies an id, a role and/or a type list
      // it is only added to the list, if the list doesn't already contain
      // an item for the id, role or type
      iMax = (*it)->getListOfColorDefinitions()->size();

      for (i = 0; i < iMax; ++i)
        {
          pColorDefinition = (*it)->getColorDefinition(i);

          if (colors.find(pColorDefinition->getId()) == colors.end())
            {
              colors.insert(std::pair<std::string, const CLColorDefinition*>(pColorDefinition->getId(), pColorDefinition));
            }
        }

      iMax = (*it)->getListOfGradientDefinitions()->size();

      for (i = 0; i < iMax; ++i)
        {
          pGradientBase = (*it)->getGradientDefinition(i);

          if (gradients.find(pGradientBase->getId()) == gradients.end())
            {
              gradients.insert(std::pair<std::string, const CLGradientBase*>(pGradientBase->getId(), pGradientBase));
            }
        }

      iMax = (*it)->getListOfLineEndings()->size();

      for (i = 0; i < iMax; ++i)
        {
          pLineEnding = (*it)->getLineEnding(i);

          if (lineEndings.find(pLineEnding->getId()) == lineEndings.end())
            {
              lineEndings.insert(std::pair<std::string, const CLLineEnding*>(pLineEnding->getId(), pLineEnding));
            }
        }

      const CLLocalRenderInformation* pRenderInformation = dynamic_cast<const CLLocalRenderInformation*>(*it);

      if (pRenderInformation)
        {
          const CLLocalStyle* pStyle = NULL;
          iMax = pRenderInformation->getListOfStyles()->size();

          for (i = 0; i < iMax; ++i)
            {
              pStyle = pRenderInformation->getStyle(i);
              const std::set<std::string>& idSet = pStyle->getKeyList();
              std::set<std::string>::const_iterator sIt = idSet.begin(), sEndit = idSet.end();

              while (sIt != sEndit)
                {
                  if (keyMap.find(*sIt) == keyMap.end())
                    {
                      keyMap.insert(std::pair<std::string, const CLStyle*>(*sIt, pStyle));
                    }

                  ++sIt;
                }

              const std::set<std::string>& roleSet = pStyle->getRoleList();

              sIt = roleSet.begin();

              sEndit = roleSet.end();

              while (sIt != sEndit)
                {
                  if (roleMap.find(*sIt) == roleMap.end())
                    {
                      roleMap.insert(std::pair<std::string, const CLStyle*>(*sIt, pStyle));
                    }

                  ++sIt;
                }

              const std::set<std::string>& typeSet = pStyle->getTypeList();

              sIt = typeSet.begin();

              sEndit = typeSet.end();

              while (sIt != sEndit)
                {
                  if (typeMap.find(*sIt) == typeMap.end())
                    {
                      typeMap.insert(std::pair<std::string, const CLStyle*>(*sIt, pStyle));
                    }

                  ++sIt;
                }
            }
        }
      else
        {
          const CLGlobalRenderInformation* pGlobalRenderInformation = dynamic_cast<const CLGlobalRenderInformation*>(*it);
          assert(pGlobalRenderInformation);
          const CLStyle* pStyle = NULL;
          iMax = pGlobalRenderInformation->getListOfStyles()->size();

          for (i = 0; i < iMax; ++i)
            {
              pStyle = pGlobalRenderInformation->getStyle(i);
              const std::set<std::string>& roleSet = pStyle->getRoleList();
              std::set<std::string>::const_iterator sIt = roleSet.begin(), sEndit = roleSet.end();

              while (sIt != sEndit)
                {
                  if (roleMap.find(*sIt) == roleMap.end())
                    {
                      roleMap.insert(std::pair<std::string, const CLStyle*>(*sIt, pStyle));
                    }

                  ++sIt;
                }

              const std::set<std::string>& typeSet = pStyle->getTypeList();

              sIt = typeSet.begin();

              sEndit = typeSet.end();

              while (sIt != sEndit)
                {
                  if (typeMap.find(*sIt) == typeMap.end())
                    {
                      typeMap.insert(std::pair<std::string, const CLStyle*>(*sIt, pStyle));
                    }

                  ++sIt;
                }
            }
        }

      ++it;
    }

  // first we collect all styles
  std::map<const CLStyle*, std::vector<std::set<std::string> > > styles;
  std::map<std::string, const CLStyle*>::const_iterator mapIt = keyMap.begin(), mapEndit = keyMap.end();

  while (mapIt != mapEndit)
    {
      if (styles.find(mapIt->second) == styles.end())
        {
          // add a new vector of sets to the map
          // the first set is for ids, the esecond for roles and  the third
          // for types
          styles[mapIt->second] = std::vector<std::set<std::string> >(3);
        }

      styles[mapIt->second][0].insert(mapIt->first);
      ++mapIt;
    }

  mapIt = roleMap.begin();
  mapEndit = roleMap.end();

  while (mapIt != mapEndit)
    {
      if (styles.find(mapIt->second) == styles.end())
        {
          // add a new vector of sets to the map
          // the first set is for ids, the esecond for roles and  the third
          // for types
          styles[mapIt->second] = std::vector<std::set<std::string> >(3);
        }

      styles[mapIt->second][1].insert(mapIt->first);
      ++mapIt;
    }

  mapIt = typeMap.begin();
  mapEndit = typeMap.end();

  while (mapIt != mapEndit)
    {
      if (styles.find(mapIt->second) == styles.end())
        {
          // add a new vector of sets to the map
          // the first set is for ids, the esecond for roles and  the third
          // for types
          styles[mapIt->second] = std::vector<std::set<std::string> >(3);
        }

      styles[mapIt->second][2].insert(mapIt->first);
      ++mapIt;
    }

  // now we create and fill the result render information
  if (local)
    {
      pResult = new CLLocalRenderInformation();
      std::map<const CLStyle*, std::vector<std::set<std::string> > >::const_iterator styleIt = styles.begin(), styleEndit = styles.end();
      CLLocalStyle* pLocalStyle = NULL;

      while (styleIt != styleEndit)
        {
          // check if the style is a local style
          // if yes, we can just clone it,
          // else it gets more complicated
          if (dynamic_cast<const CLLocalStyle*>(styleIt->first))
            {
              dynamic_cast<CLLocalRenderInformation*>(pResult)->addStyle(static_cast<const CLLocalStyle*>(styleIt->first));
            }
          else
            {
              pLocalStyle = convertGlobalToLocalStyle(static_cast<const CLGlobalStyle*>(styleIt->first));
              dynamic_cast<CLLocalRenderInformation*>(pResult)->addStyle(pLocalStyle);
              delete pLocalStyle;
            }

          ++styleIt;
        }
    }
  else
    {
      pResult = new CLGlobalRenderInformation();
      std::map<const CLStyle*, std::vector<std::set<std::string> > >::const_iterator styleIt = styles.begin(), styleEndit = styles.end();

      while (styleIt != styleEndit)
        {
          static_cast<CLGlobalRenderInformation*>(pResult)->addStyle(dynamic_cast<const CLGlobalStyle*>(styleIt->first));
          ++styleIt;
        }
    }

  // fill the color, gradients and line endings
  std::map<std::string, const CLColorDefinition*>::const_iterator colorIt = colors.begin(), colorEndit = colors.end();

  while (colorIt != colorEndit)
    {
      pResult->addColorDefinition(colorIt->second);
      ++colorIt;
    }

  std::map<std::string, const CLGradientBase*>::const_iterator gradientIt = gradients.begin(), gradientEndit = gradients.end();

  while (gradientIt != gradientEndit)
    {
      pResult->addGradientDefinition(gradientIt->second);
      ++gradientIt;
    }

  std::map<std::string, const CLLineEnding*>::const_iterator lineIt = lineEndings.begin(), lineEndit = lineEndings.end();

  while (lineIt != lineEndit)
    {
      pResult->addLineEnding(lineIt->second);
      ++lineIt;
    }

  pResult->setBackgroundColor(renderInformation.getBackgroundColor());
  return pResult;
}

CLGlobalRenderInformation * CLRenderFlattener::flatten_render_information ( const CLGlobalRenderInformation &  globalRenderInformation, const CCopasiVector< CLGlobalRenderInformation > &  globalList  ) throw ( CLUnresolvedReferenceException )

static

static method that takes a const reference to a global render information object and resolves all references. The returned object is a new global render information object and the caller is responsible for freeing the memory once it is no longer used. If references can not be resolved, an unresolved_reference_exception is thrown.

Definition at line 36 of file CLRenderFlattener.cpp.

References flatten().

{
  return dynamic_cast<CLGlobalRenderInformation*>(CLRenderFlattener::flatten(globalRenderInformation, globalList));
}

CLLocalRenderInformation * CLRenderFlattener::flatten_render_information ( const CLLocalRenderInformation &  localRenderInformation, const CCopasiVector< CLLocalRenderInformation > &  localList, const CCopasiVector< CLGlobalRenderInformation > &  globalList  ) throw ( CLUnresolvedReferenceException )

static

static method that takes a const reference to a local render information object and resolves all references. The returned object is a new local render information object and the caller is responsible for freeing the memory once it is no longer used. If references can not be resolved, an unresolved_reference_exception is thrown.

Definition at line 49 of file CLRenderFlattener.cpp.

References flatten().

{
  return dynamic_cast<CLLocalRenderInformation*>(CLRenderFlattener::flatten(localRenderInformation, globalList, localList));
}

---

The documentation for this class was generated from the following files:

• CLRenderFlattener.h
• CLRenderFlattener.cpp