D3PD::VectorFillerToolBase::Var Class Reference

Description for a single variable. More...

Collaboration diagram for D3PD::VectorFillerToolBase::Var:

Public Member Functions
	Var (const std::string &name, const std::type_info &ti, void *&ptr, const std::string &dim, char *defval, size_t defsize)
	Constructor. More...
StatusCode	init (IAddVariable *tree, const std::string &prefix)
	Initialize the variable. More...
void	resize (size_t sz, size_t pos)
	Resize the vector. More...
void	next ()
	Move the variable pointer to the next element. More...
void	free ()
	Free allocated storage. More...

Private Attributes
std::string	m_name
	The variable name. More...
const std::type_info *	m_ti
	The type of the variable element (for each object). More...
char **	m_addr
	Pointer to the variable pointer. More...
std::string	m_docstring
	Documentation string. More...
TVirtualCollectionProxy *	m_proxy
	The root collection proxy. More...
size_t	m_valdiff
	Offset between collection elements. More...
void *	m_contptr
	Pointer to the vector instance. More...
char *	m_default
	Pointer to the default value for this variable, if one has been requested. More...
size_t	m_defsize
	Size of the object pointed to by m_default. More...

Detailed Description

Description for a single variable.

We need to be able to resize the vector and quickly adjust the pointer to the next entry. So we save the root collection proxy and the element-to-element to offset. So to move to a new element, all we need to do is to add the offset to the variable pointer.

The vector must have a root dictionary (but not necessarily a reflex dictionary).

Definition at line 227 of file VectorFillerToolBase.h.

Constructor & Destructor Documentation

Var()

D3PD::VectorFillerToolBase::Var::Var	(	const std::string &	name,
		const std::type_info &	ti,
		void *&	ptr,
		const std::string &	docstring,
		char *	defval,
		size_t	defsize
	)

Constructor.

Parameters

name	The variable name (without prefix).
ti	The element type of the variable.
ptr	The variable pointer provided by the block filler tool.
dim	Reserved.
defval	Pointer to the default value to use for this variable. Null for no default. Of the type given by ti. Only works for basic types. We take ownership of this.
defsize	Size of the object pointed at by defval.
name	The variable name (without prefix).
ti	The element type of the variable.
ptr	The variable pointer provided by the block filler tool.
docstring	Documentation string.
defval	Pointer to the default value to use for this variable. Null for no default. Of the type given by ti. Only works for basic types. We take ownership of this.
defsize	Size of the object pointed at by defval.

Definition at line 408 of file VectorFillerToolBase.cxx.

  : m_name (name),
    m_ti (&ti),
    m_addr (reinterpret_cast<char**> (&ptr)),
    m_docstring (docstring),
    m_proxy (0),
    m_valdiff (0),
    m_contptr (0),
    m_default (defval),
    m_defsize (defsize)
{
}

Member Function Documentation

free()

void D3PD::VectorFillerToolBase::Var::free

(

)

Free allocated storage.

Don't do this from the destructor since these guys get used in a vector.

Definition at line 542 of file VectorFillerToolBase.cxx.

{
  delete [] m_default;
}

init()

StatusCode D3PD::VectorFillerToolBase::Var::init	(	IAddVariable *	tree,
		const std::string &	prefix
	)

Initialize the variable.

Parameters

tree	The parent tree.
prefix	The variable name prefix.

Definition at line 432 of file VectorFillerToolBase.cxx.

{
  // Get the name of the element variable.
  std::string eltname = typeinfoToName (*m_ti);
 
  // Use vector<int> instead of vector<bool>.
  if (eltname == "bool")
    eltname = "int";
 
  // Construct the vector name.
  std::string vname = "std::vector<" + eltname;
  if (vname[vname.size()-1] == '>')
    vname += ' ';
  vname += '>';
 
  // Fetch the root dictionary for the vector and find the proxy.
  TClass* cls = TClass::GetClass (vname.c_str());
  if (!cls) {
    REPORT_MESSAGE(MSG::ERROR) << "Can't find TClass for type "
                               << vname
                               << " for variable "
                               << prefix + m_name;
    return StatusCode::FAILURE;
  }
  m_proxy = cls->GetCollectionProxy();
 
  if (!m_proxy) {
    REPORT_MESSAGE(MSG::ERROR) << "Can't find root collection proxy for type "
                               << vname
                               << " for variable "
                               << prefix + m_name;
    return StatusCode::FAILURE;
  }
 
  if (!m_proxy->GetCollectionClass() ||
      !m_proxy->GetCollectionClass()->GetTypeInfo())
  {
    REPORT_MESSAGE(MSG::ERROR) << "Dictionary error for collection class "
                               << vname
                               << " for variable "
                               << prefix + m_name;
    return StatusCode::FAILURE;
  }
 
  // Will be set at the first resize().
  m_valdiff = 0;
 
  // Create the vector.
  m_contptr = 0;
  return tree->addVariable (prefix + m_name,
                            *m_proxy->GetCollectionClass()->GetTypeInfo(),
                            // cppcheck-suppress nullPointer; false positive
                            m_contptr,
                            m_docstring);
}

next()

void D3PD::VectorFillerToolBase::Var::next ( )

inline

Move the variable pointer to the next element.

Definition at line 32 of file VectorFillerToolBase.cxx.

{
  *m_addr += m_valdiff;
}

resize()

void D3PD::VectorFillerToolBase::Var::resize	(	size_t	sz,
		size_t	pos
	)

Resize the vector.

Parameters

sz	The new vector size.
pos	After the resize, move the variable pointer to this element.

Definition at line 495 of file VectorFillerToolBase.cxx.

{
  // Resize the vector.
  TVirtualCollectionProxy::TPushPop pushcont (m_proxy, m_contptr);
  size_t oldsz = m_proxy->Size();
  m_proxy->Allocate (sz, false);
  if (sz == 0) {
    *m_addr = 0;
    return;
  }
 
  char* begin = static_cast<char*> (m_proxy->At(0));
 
  // Calculate the element offset, if needed.
  // We do this by finding the difference between the first two
  // elements, so we can only do this if there are at least two elements
  // in the vector.  But if there are less than two elements, then
  // the offset doesn't matter anyway.
  if (m_valdiff == 0 && sz >= 2)
    m_valdiff = static_cast<char*> (m_proxy->At(1)) - begin;
 
  // Set the pointer properly.
  *m_addr = begin + pos * m_valdiff;
 
  // Fill in default value if requested.
  if (m_default && sz > oldsz) {
    if (sz == 1) {
      std::memcpy (begin, m_default, m_defsize);
    }
    else {
      assert (m_defsize <= m_valdiff);
      for (char* p = begin + oldsz * m_valdiff;
           p < begin + sz * m_valdiff;
           p += m_valdiff)
      {
        std::memcpy (p, m_default, m_defsize);
      }
    }
  }
}

Member Data Documentation

m_addr

char** D3PD::VectorFillerToolBase::Var::m_addr

private

Pointer to the variable pointer.

Definition at line 290 of file VectorFillerToolBase.h.

m_contptr

void* D3PD::VectorFillerToolBase::Var::m_contptr

private

Pointer to the vector instance.

Definition at line 302 of file VectorFillerToolBase.h.

m_default

char* D3PD::VectorFillerToolBase::Var::m_default

private

Pointer to the default value for this variable, if one has been requested.

We own this object.

Definition at line 306 of file VectorFillerToolBase.h.

m_defsize

size_t D3PD::VectorFillerToolBase::Var::m_defsize

private

Size of the object pointed to by m_default.

(Should generally be the same as m_valdiff, but it may possibly be smaller due to alignment considerations.)

Definition at line 311 of file VectorFillerToolBase.h.

m_docstring

std::string D3PD::VectorFillerToolBase::Var::m_docstring

private

Documentation string.

Definition at line 293 of file VectorFillerToolBase.h.

m_name

std::string D3PD::VectorFillerToolBase::Var::m_name

private

The variable name.

Definition at line 284 of file VectorFillerToolBase.h.

m_proxy

TVirtualCollectionProxy* D3PD::VectorFillerToolBase::Var::m_proxy

private

The root collection proxy.

Definition at line 296 of file VectorFillerToolBase.h.

m_ti

const std::type_info* D3PD::VectorFillerToolBase::Var::m_ti

private

The type of the variable element (for each object).

Definition at line 287 of file VectorFillerToolBase.h.

m_valdiff

size_t D3PD::VectorFillerToolBase::Var::m_valdiff

private

Offset between collection elements.

Definition at line 299 of file VectorFillerToolBase.h.

---

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

• VectorFillerToolBase.h
• VectorFillerToolBase.cxx