CollectionColumn.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef COLLECTIONSVC_COLLECTIONCOLUMN_H
#define COLLECTIONSVC_COLLECTIONCOLUMN_H
 
#include "ICollectionColumn.h"
 
#include "CoralBase/AttributeSpecification.h"
 
#include <typeinfo>
 
 
namespace pool {

  class CollectionColumn : virtual public pool::ICollectionColumn
  {
  public:
    CollectionColumn()
      : m_name( "" ),
        m_type( "" ),
        m_maxSize( 0 ),
        m_sizeIsFixed( true ),
        m_id( 0 ) {}

    CollectionColumn( const std::string& name,
                      const std::string& type,
                      int maxSize = 0,
                      bool sizeIsFixed = true )
      : m_name( name ),
        m_type( type ),
        m_maxSize( maxSize ),
        m_sizeIsFixed( sizeIsFixed ),
        m_id( 0 ) {}

    CollectionColumn( const CollectionColumn& rhs )
      : ICollectionColumn(),
        m_name( rhs.m_name ),
        m_type( rhs.m_type ),
        m_maxSize( rhs.m_maxSize ),
        m_sizeIsFixed( rhs.m_sizeIsFixed ),
        m_id( rhs.m_id ) 
    {}
     
    ~CollectionColumn() {}

    CollectionColumn& operator=( const CollectionColumn& rhs )
    {
      m_name = rhs.m_name;
      m_type = rhs.m_type;
      m_maxSize = rhs.m_maxSize;
      m_sizeIsFixed = rhs.m_sizeIsFixed;
      m_id = rhs.m_id; 
   
      return *this;
    }

    bool operator==( const CollectionColumn& rhs ) const
    {
      return
     m_name == rhs.m_name &&
     m_type == rhs.m_type &&
     m_maxSize == rhs.m_maxSize &&
     m_sizeIsFixed == rhs.m_sizeIsFixed
     // && m_id == rhs.m_id   //MN - does not matter?
     ;
    }

    bool operator!=( const CollectionColumn& rhs ) const
    {
      return !( *this == rhs );
    }
    
    virtual void setName( const std::string& name ) { m_name = name; }

    virtual void setType( const std::string& type ) { m_type = type; }

    virtual void setType( const std::type_info& type )
    { m_type = coral::AttributeSpecification::typeNameForId( type ); }

    virtual void setMaxSize( int maxSize ) { m_maxSize = maxSize; }

    virtual void setSizeIsFixed( bool sizeIsFixed ) { m_sizeIsFixed = sizeIsFixed; }

    virtual void setId( int id ) { m_id = id; }
  
    virtual const std::string& name() const { return m_name; }

    virtual const std::string& type() const { return m_type; }

    virtual int maxSize() const { return m_maxSize; }

    virtual bool sizeIsFixed() const { return m_sizeIsFixed; }

    virtual int id() const { return m_id; }
 
  private:
    std::string m_name;

    std::string m_type;

    int m_maxSize;

    bool m_sizeIsFixed;

    int m_id;
  };
 
}
 
#endif