daiAggr.h

Go to the documentation of this file.

// Copyright (C) 2002-2019, 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-2019 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 _DAI_AGGR_H
#define _DAI_AGGR_H
 
#include "OdPlatformSettings.h"
#include "OdaCommon.h"
#include "RxObject.h"
#include "RxObjectImpl.h"
#include "SharedPtr.h"
 
#include "daiBuildOptions.h"
#include "daiObjectId.h"
#include "daiIterator.h"
 
namespace OdDAI {
 
  class DAI_EXPORT AggrInstance
  {
  public:
 
    virtual ~AggrInstance() {};
    virtual IteratorPtr createIterator() const = 0;
    virtual const OdRxValueType& type() const = 0;
    virtual int size() const = 0;
    virtual AggrInstance* duplicate() const = 0;
  };
 
  template<class T>
  class DAI_EXPORT AggrInstanceTyped : public AggrInstance
  {
    OdArray<T> m_arr;
 
    AggrInstanceTyped(const OdArray<T> &arr) { m_arr = arr; };
 
  public:
 
    AggrInstanceTyped() {};
 
    const OdArray<T>& getArray() const
    {
      return m_arr;
    }
 
    void operator = (const OdArray<T> &rhs) { m_arr = rhs; };
 
    operator OdArray<T>& () { return m_arr; }
 
    operator const OdArray<T>& () { return m_arr; }
 
    virtual IteratorPtr createIterator() const {
      IteratorPtr pIter = new IteratorArr<T>(m_arr);
      return pIter;
    }
 
    virtual const OdRxValueType& type() const {
      return OdRxValueType::Desc<T>::value();
    }
 
    virtual int size() const {
      return m_arr.size();
    }
 
    virtual AggrInstance* duplicate() const {
      return new AggrInstanceTyped<T>(m_arr);
    };
 
  };
 
 
 
  class DAI_EXPORT AggrBase
  {
  public:
 
    ~AggrBase();
 
    IteratorPtr createIterator() const;
 
    bool isNil() const {
      return (m_pInst == NULL);
    }
 
    unsigned long length() const;
 
    //DOM-IGNORE-BEGIN
 
    AggrInstance* instance() {
      return m_pInst;
    }
 
  protected:
 
    AggrInstance *m_pInst;
 
    AggrBase()
      : m_pInst(NULL)
    {}
 
    AggrBase(const AggrBase& other)
      : m_pInst(NULL)
    {
      if (other.m_pInst)
      {
        m_pInst = other.m_pInst->duplicate();
      }
    }
 
    //DOM-IGNORE-END
 
  };
 
  template<class T>
  class DAI_EXPORT Aggr : public AggrBase
  {
  public:
 
    Aggr<T>& operator = (const OdArray<T> &rhs)
    {
      delete m_pInst;
      if (rhs.size() == 0)
      {
        m_pInst = NULL;
        return *this;
      }
      init(rhs);
      return *this;
    };
 
    operator OdArray<T> () const
    {
      return getArray();
    }
 
    OdArray<T> getArray() const
    {
      if (m_pInst)
      {
        AggrInstanceTyped<T> *pTyped = dynamic_cast<AggrInstanceTyped<T>*>(m_pInst);
        if (pTyped)
          return pTyped->getArray();
      }
      return OdArray<T>();
    }
 
  protected:
 
    void init(const OdArray<T> &arr)
    {
      AggrInstanceTyped<T> *pInst = new AggrInstanceTyped<T>();
      *pInst = arr;
      m_pInst = pInst;
    }
  };
 
  typedef Aggr< bool > BoolAggr;
  typedef OdSharedPtr< BoolAggr > BoolAggrPtr;
 
  typedef Aggr< double > DoubleAggr;
  typedef OdSharedPtr< DoubleAggr > DoubleAggrPtr;
 
  typedef Aggr< int > IntAggr;
  typedef OdSharedPtr< IntAggr > IntAggrPtr;
 
  typedef Aggr< OdDAIObjectId > OdDAIObjectIdAggr;
  typedef OdSharedPtr< OdDAIObjectIdAggr > OdDAIObjectIdAggrPtr;
 
}
 
#endif // _DAI_DICTIONARY_INSTANCE_H