RootUtils::Type Class Reference

Wrapper for ROOT types. More...

#include <Type.h>

Collaboration diagram for RootUtils::Type:

Classes
class	Deleter
	Deleter object, compatible with std::unique_ptr. More...

Public Types
typedef std::unique_ptr< void, Deleter >	unique_ptr
	A std::unique_ptr type referencing a generic pointer. More...

Public Member Functions
	Type ()
	Default constructor. More...
	Type (TClass *cls)
	Construct for a class type. More...
	Type (EDataType type)
	Construct for a fundamental type. More...
	Type (const std::string &typname)
	Construct from a type name. More...
	Type (const RootUtils::Type &other)
	Copy constructor. More...
Type &	operator= (const RootUtils::Type &other)
	Assignment. More...
	~Type ()
	Destructor. More...
void	init (const std::string &typname)
	Initialize from a type name. More...
void	init (TClass *cls)
	Initialize for a class type. More...
void	init (EDataType type)
	Initialize for a fundamental data type. More...
void *	create () const
	Create an instance of the object. More...
void	destroy (void *p) const
	Destroy an instance of the object (and free memory). More...
std::string	getTypeName () const
	Return the name of this type. More...
const TClass *	getClass () const
	Return the ROOT class for the described type. More...
EDataType	getDataType () const
	Return the ROOT data type code for the described type. More...
const std::type_info *	getTypeInfo () const
	Return the type_info for the described type. More...
size_t	getSize () const
	Return the size in bytes of an instance of the described type. More...
void	copyRange (void *dst, const void *src, size_t n) const
	Copy a range of objects. More...
void	clearRange (void *dst, size_t n) const
	Clear a range of objects. More...
void	clearRange (void *dst, size_t index, size_t n) const
	Clear a range of objects. More...
void	clear (void *dst, size_t index) const
	Clear an object in a vector. More...
void	clear (void *dst) const
	Clear an object. More...
void	assign (void *dst, size_t dst_index, const void *src, size_t src_index) const
	Copy an object within vectors. More...
void	assign (void *dst, const void *src) const
	Copy an object. More...
void	swap (void *a, size_t a_index, void *b, size_t b_index) const
	Swap an object between vectors. More...
void	swap (void *a, void *b) const
	Swap two objects. More...
void	swapRange (void *a, size_t a_index, void *b, size_t b_index, size_t n) const
	Swap a range of objects between vectors. More...
void	fromString (void *p, const std::string &s) const
	Initialize an object from a string. More...

Private Attributes
TClass *	m_cls
	The class of the derived type, or 0 if it's not a class type. More...
EDataType	m_type
	The ROOT type code of the derived type, or kNoType_t for a class type. More...
const std::type_info *	m_ti
	The type_info for the described type. More...
size_t	m_size
	The size in bytes of an instance of the described type. More...
TSMethodCall m_assign	ATLAS_THREAD_SAFE
void *	m_defElt
	Pointer to a default-constructed instance of the payload object. More...

Detailed Description

Wrapper for ROOT types.

Using the ROOT interfaces to manipulate objects of generic type is rather awkward, because you have do to completely different things depending on whether the type of object you're dealing with is a class or a fundamental type. This wrapper allows treating these two cases in a uniform way. For now, we don't try to handle other kinds of types (pointers, etc).

Definition at line 39 of file Type.h.

Member Typedef Documentation

unique_ptr

typedef std::unique_ptr<void, Deleter> RootUtils::Type::unique_ptr

A std::unique_ptr type referencing a generic pointer.

You need to pass in the type when constructing it, like this:

RootUtils::Type typ (...);
RootUtils::Type::unique_ptr up (typ.create(), typ);

Definition at line 344 of file Type.h.

Constructor & Destructor Documentation

Type() [1/5]

RootUtils::Type::Type

(

)

Default constructor.

Wrapper for ROOT types.

The only thing you can do with the resulting object is to call init() on it.

Using the ROOT interfaces to manipulate objects of generic type is rather awkward, because you have do to completely different things depending on whether the type of object you're dealing with is a class or a fundamental type. This wrapper allows treating these two cases in a uniform way. For now, we don't try to handle other kinds of types (pointers, etc).

Definition at line 35 of file Type.cxx.

  : m_cls(0),
    m_type(kNoType_t),
    m_ti(0),
    m_size(0),
    m_defElt(0)
{
}

Type() [2/5]

RootUtils::Type::Type

(

TClass *

cls

)

Construct for a class type.

Parameters

cls	The class of the object on which we're operating.

Definition at line 49 of file Type.cxx.

  : m_cls(0),
    m_type(kNoType_t),
    m_ti(0),
    m_size(0),
    m_defElt(0)
{
  init (cls);
}

Type() [3/5]

RootUtils::Type::Type

(

EDataType

type

)

Construct for a fundamental type.

Parameters

type	The ROOT type code.

Definition at line 64 of file Type.cxx.

  : m_cls(0),
    m_type(kNoType_t),
    m_ti(0),
    m_size(0),
    m_defElt(0)
{
  init (type);
}

Type() [4/5]

RootUtils::Type::Type

(

const std::string &

typname

)

Construct from a type name.

Parameters

typname

The name of the type.

typname may be either the name of a fundamental type, or the name of a class known to ROOT. An exception will be thrown if the name is not recognized.

Definition at line 83 of file Type.cxx.

  : m_cls(0),
    m_type(kNoType_t),
    m_ti(0),
    m_size(0),
    m_defElt(0)
{
  init (typname);
}

Type() [5/5]

RootUtils::Type::Type

(

const RootUtils::Type &

other

)

Copy constructor.

Parameters

other

Object to be copied.

Definition at line 98 of file Type.cxx.

  : m_cls (other.m_cls),
    m_type (other.m_type),
    m_ti (other.m_ti),
    m_size (other.m_size),
    m_assign (other.m_assign),
    m_defElt (0)
{
  if (m_cls)
    m_defElt = create();
}

~Type()

RootUtils::Type::~Type

(

)

Destructor.

Definition at line 137 of file Type.cxx.

{
  if (m_defElt)
    destroy (m_defElt);
}

Member Function Documentation

assign() [1/2]

void RootUtils::Type::assign	(	void *	dst,
		const void *	src
	)		const

Copy an object.

Parameters

dst	Destination for the copy.
src	Source for the copy.

The copy will be done using either m_assign or memcpy, depending on whether or not the object has class type. If the payload does not have class type and src is null, then the destination element will be filled with 0's.

Definition at line 499 of file Type.cxx.

{
  if (TMethodCall* meth = m_assign.call()) {
    meth->ResetParam();
    meth->SetParam (reinterpret_cast<Long_t>(src));
    meth->Execute (dst);
  }
  else {
    if (src)
      memcpy (dst, src, m_size);
    else
      memset (dst, 0, m_size);
  }
}

assign() [2/2]

void RootUtils::Type::assign	(	void *	dst,
		size_t	dst_index,
		const void *	src,
		size_t	src_index
	)		const

Copy an object within vectors.

Parameters

dst	Pointer to the start of the destination vector's data.
dst_index	Index of destination object in the vector.
src	Pointer to the start of the source vector's data.
src_index	Index of source object in the vector.

dst and @ src can be either the same or different.

Definition at line 480 of file Type.cxx.

{
  dst = reinterpret_cast<void*>(reinterpret_cast<unsigned long>(dst) + m_size* dst_index);
  src = reinterpret_cast<const void*>(reinterpret_cast<unsigned long>(src) + m_size * src_index);
  assign (dst, src);
}

clear() [1/2]

void RootUtils::Type::clear

(

void *

dst

)

const

Clear an object.

Parameters

dst	Pointer to the object.

Definition at line 465 of file Type.cxx.

{
  assign (dst, m_defElt);
}

clear() [2/2]

void RootUtils::Type::clear	(	void *	dst,
		size_t	index
	)		const

Clear an object in a vector.

Parameters

dst	Pointer to the start of the vector's data.
index	Index of the object in the vector.

Definition at line 454 of file Type.cxx.

{
  dst = reinterpret_cast<void*>(reinterpret_cast<unsigned long>(dst) + m_size* index);
  assign (dst, m_defElt);
}

clearRange() [1/2]

void RootUtils::Type::clearRange	(	void *	dst,
		size_t	index,
		size_t	n
	)		const

Clear a range of objects.

Parameters

dst	Pointer to the start of vector's data.
index	Index of the first element to clear.
n	Number of objects to clear.

Objects of class type are cleared by assigning to them a default-constructed object. Other objects types are cleared by filling with 0.

Definition at line 443 of file Type.cxx.

{
  clearRange (reinterpret_cast<char*> (dst) + index * m_size, n);
}

clearRange() [2/2]

void RootUtils::Type::clearRange	(	void *	dst,
		size_t	n
	)		const

Clear a range of objects.

Parameters

dst	Pointer to the start of the first object to clear.
n	Number of objects to clear.

Objects of class type are cleared by assigning to them a default-constructed object. Other objects types are cleared by filling with 0.

Definition at line 420 of file Type.cxx.

{
  if (m_cls) {
    for (size_t i = 0; i < n; ++i) {
      clear (dst, i);
    }
  }
  else {
    memset (dst, 0, n * m_size);
  }
}

copyRange()

void RootUtils::Type::copyRange	(	void *	dst,
		const void *	src,
		size_t	n
	)		const

Copy a range of objects.

Parameters

dst	Pointer to the start of the first object for the destination.
src	Pointer to the start of the first object for the copy source.
n	Number of objects to copy.

This function properly handles overlapping ranges.

Definition at line 389 of file Type.cxx.

{
  if (m_cls) {
    if (dst > src && reinterpret_cast<unsigned long>(src) + n*m_size > reinterpret_cast<unsigned long>(dst))
    {
      for (size_t i = n-1; i < n; --i) {
        assign (dst, i, src, i);
      }
    }
    else
    {
      for (size_t i = 0; i < n; ++i) {
        assign (dst, i, src, i);
      }
    }
  }
  else {
    memmove (dst, src, n * m_size);
  }
}

create()

void * RootUtils::Type::create

(

)

const

Create an instance of the object.

Class objects will be default-constructed; fundamental types will be zero-filled.

Definition at line 296 of file Type.cxx.

{
  if (m_cls)
    return m_cls->New();
  void* p = new char[m_size];
  clear (p);
  return p;
}

destroy()

void RootUtils::Type::destroy

(

void *

p

)

const

Destroy an instance of the object (and free memory).

Parameters

p	Pointer to the object to be destroyed and freed.

Definition at line 310 of file Type.cxx.

{
  if (p) {
    if (m_cls) {
      // TClass::Destructor is non-const.
      // But there's nothing obviously problematic in it...
      // just suppress the checker warning for now.
      TClass* cls ATLAS_THREAD_SAFE = m_cls;
      cls->Destructor (p);
    }
    else
      delete [] (reinterpret_cast<char*> (p));
  }
}

fromString()

void RootUtils::Type::fromString	(	void *	p,
		const std::string &	s
	)		const

Initialize an object from a string.

Parameters

p	Pointer to the object to initialize.
s	String from which to initialize.

Only works for basic types and std::string.

Definition at line 601 of file Type.cxx.

{
  std::istringstream is (s);
  switch (m_type) {
#define TYPE(CODE, TYP, IOTYP) case CODE: { IOTYP tmp=0; is >> tmp; *reinterpret_cast<TYP*>(p) = tmp; } return
#include "Types.def"
#undef TYPE
  default: break;
  }
 
  if (m_cls == TClass::GetClass ("string")) {
    *reinterpret_cast<std::string*>(p) = s;
    return;
  }
 
  throw std::runtime_error
    (std::string ("RootUtils::Type::fromString: Can't convert objects of type `" +
                  getTypeName() + "'."));
}

getClass()

const TClass * RootUtils::Type::getClass

(

)

const

Return the ROOT class for the described type.

Returns 0 if this is for a fundamental type.

Definition at line 346 of file Type.cxx.

{
  return m_cls;
}

getDataType()

EDataType RootUtils::Type::getDataType

(

)

const

Return the ROOT data type code for the described type.

Returns kNoType_t if this is for a class type.

Definition at line 357 of file Type.cxx.

{
  return m_type;
}

getSize()

size_t RootUtils::Type::getSize

(

)

const

Return the size in bytes of an instance of the described type.

Definition at line 375 of file Type.cxx.

{
  return m_size;
}

getTypeInfo()

const std::type_info * RootUtils::Type::getTypeInfo

(

)

const

Return the type_info for the described type.

Definition at line 366 of file Type.cxx.

{
  return m_ti;
}

getTypeName()

std::string RootUtils::Type::getTypeName

(

)

const

Return the name of this type.

Definition at line 329 of file Type.cxx.

{
  if (m_type != kNoType_t)
    return TDataType::GetTypeName (m_type);
 
  if (m_cls)
    return m_cls->GetName();
 
  return "";
}

init() [1/3]

void RootUtils::Type::init

(

const std::string &

type_name

)

Initialize from a type name.

Parameters

typname

The name of the type.

The Type object must have been just default-constructed.

typname may be either the name of a fundamental type, or the name of a class known to ROOT. An exception will be thrown if the name is not recognized.

Parameters

type_name

The name of the type.

The Type object must have been just default-constructed.

type_name may be either the name of a fundamental type, or the name of a class known to ROOT. An exception will be thrown if the name is not recognized.

Definition at line 154 of file Type.cxx.

{
  // Make sure root's table of types is initialized.
  // May be needed for root 6.
  gROOT->GetListOfTypes();
 
  assert (m_cls == 0 && m_type == kNoType_t);
 
  TClass* cls = TClass::GetClass (type_name.c_str());
  if (cls) {
    init (cls);
    return;
  }
 
  for (int i = 0; i < kNumDataTypes; ++i) {
    EDataType type = static_cast<EDataType>(i);
    TDataType* dt = TDataType::GetDataType(type);
    if (dt && type_name == dt->GetTypeName()) {
      init (type);
      return;
    }
  }
 
  EDataType type = kNoType_t;
  // Check for some other synonyms.
  // RNTuple likes to prepend "std::" to type names - remove it before comparison
  std::string tname;
  if( type_name.rfind("std::", 0) == 0 ) {
     // remove std:: prefix if present
     tname = type_name.substr(5);
  } else {
     tname = type_name;
  }
  if (tname == "uint32_t") {
    if (sizeof (unsigned int) == 4)
      type = kUInt_t;
  }
  else if (tname == "int32_t") {
    if (sizeof (unsigned int) == 4)
      type = kInt_t;
  }
  else if (tname == "uint16_t") {
    if (sizeof (unsigned short) == 2)
      type = kUShort_t;
  }
  else if (tname == "int16_t") {
    if (sizeof (short) == 2)
      type = kShort_t;
  }
  else if (tname == "uint8_t") {
    type = kUChar_t;
  }
  else if (tname == "int8_t") {
    type = kChar_t;
  }
  else if (tname == "uint64_t") {
    if (sizeof(unsigned long) == 8)
      type = kULong_t;
    else if (sizeof(unsigned long long) == 8)
      type = kULong64_t;
        
  }
  else if (tname == "int64_t") {
    if (sizeof(long) == 8)
      type = kLong_t;
    else if (sizeof(long long) == 8)
      type = kLong64_t;
  }
 
  if (type != kNoType_t) {
    init (type);
    return;
  }
 
  throw std::runtime_error (std::string ("RootUtils::Type: Can't find type `") +
                            type_name + "'.");
}

init() [2/3]

void RootUtils::Type::init

(

EDataType

type

)

Initialize for a fundamental data type.

Parameters

type	The ROOT type code.

The Type object must have been just default-constructed.

Definition at line 264 of file Type.cxx.

{
  // Make sure root's table of types is initialized.
  // May be needed for root 6.
  gROOT->GetListOfTypes();
 
  assert (m_cls == 0 && m_type == kNoType_t);
  TDataType* dt = TDataType::GetDataType (type);
  if (!dt) {
    throw std::runtime_error ("Unknown data type");
  }
 
  m_cls = 0;
  m_type = type;
  m_size = dt->Size();
  m_defElt = 0;
 
  switch (type) {
#define TYPE(CODE, TYP, IOTYP) case CODE: m_ti = &typeid(TYP); break
#include "Types.def"
#undef TYPE
  default: break;
  }
}

init() [3/3]

void RootUtils::Type::init

(

TClass *

cls

)

Initialize for a class type.

Parameters

cls	The class of the object on which we're operating.

The Type object must have been just default-constructed.

Definition at line 239 of file Type.cxx.

{
  assert (m_cls == 0 && m_type == kNoType_t);
  m_cls = cls;
  m_type = kNoType_t;
  m_size = cls->Size();
  m_defElt = create();
  m_ti = cls->GetTypeInfo();
 
  std::string fname = "operator=";
 
  std::string assignProto = "const ";
  assignProto += m_cls->GetName();
  assignProto += "&";
 
  m_assign.setProto (m_cls, fname, assignProto);
}

operator=()

Type & RootUtils::Type::operator=

(

const RootUtils::Type &

other

)

Assignment.

Parameters

other

Object to be copied.

Definition at line 115 of file Type.cxx.

{
  if (this != &other) {
    m_cls = other.m_cls;
    m_type = other.m_type;
    m_ti = other.m_ti;
    m_size = other.m_size;
    m_assign = other.m_assign;
    if (m_defElt)
      destroy (m_defElt);
    if (m_cls)
      m_defElt = create();
    else
      m_defElt = 0;
  }
  return *this;
}

swap() [1/2]

void RootUtils::Type::swap	(	void *	a,
		size_t	a_index,
		void *	b,
		size_t	b_index
	)		const

Swap an object between vectors.

Parameters

a	Pointer to the start of the first vector's data.
aindex	Index of the object in the first vector.
b	Pointer to the start of the second vector's data.
bindex	Index of the object in the second vector.

a and @ b can be either the same or different.

Definition at line 524 of file Type.cxx.

{
  a = reinterpret_cast<void*>(reinterpret_cast<unsigned long>(a) + m_size*a_index);
  b = reinterpret_cast<void*>(reinterpret_cast<unsigned long>(b) + m_size*b_index);
  swap (a, b);
}

swap() [2/2]

void RootUtils::Type::swap	(	void *	a,
		void *	b
	)		const

Swap two objects.

Parameters

a	Pointer to the first object.
b	Pointer to the second object.

Definition at line 538 of file Type.cxx.

{
  if (m_assign.call() != nullptr) {
    void* tmp = create();
    assign (tmp, a);
    assign (a, b);
    assign (b, tmp);
    destroy (tmp);
  }
  else {
    std::vector<char> tmp (m_size);
    memcpy (tmp.data(), a, m_size);
    memcpy (a, b, m_size);
    memcpy (b, tmp.data(), m_size);
  }
}

swapRange()

void RootUtils::Type::swapRange	(	void *	a,
		size_t	a_index,
		void *	b,
		size_t	b_index,
		size_t	n
	)		const

Swap a range of objects between vectors.

Parameters

a	Pointer to the start of the first vector's data.
aindex	Index of the first object in the first vector.
b	Pointer to the start of the second vector's data.
bindex	Index of the second object in the second vector.
n	Number of objects to swap.

a and @ b can be either the same or different. However, the ranges should not overlap.

Definition at line 567 of file Type.cxx.

{
  char* aptr = reinterpret_cast<char*>(a) + m_size * a_index;
  char* bptr = reinterpret_cast<char*>(b) + m_size * b_index;
 
  if (m_assign.call() != nullptr) {
    void* tmp = create();
    for (size_t i = 0; i < n; i++) {
      assign (tmp, aptr);
      assign (aptr, bptr);
      assign (bptr, tmp);
      aptr += m_size;
      bptr += m_size;
    }
    destroy (tmp);
  }
  else {
    std::vector<char> tmp (m_size * n);
    memcpy (tmp.data(), aptr, m_size * n);
    memcpy (aptr, bptr, m_size * n);
    memcpy (bptr, tmp.data(), m_size * n);
  }
}

Member Data Documentation

ATLAS_THREAD_SAFE

TSMethodCall m_assign RootUtils::Type::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 361 of file Type.h.

m_cls

TClass* RootUtils::Type::m_cls

private

The class of the derived type, or 0 if it's not a class type.

Definition at line 349 of file Type.h.

m_defElt

void* RootUtils::Type::m_defElt

private

Pointer to a default-constructed instance of the payload object.

Null if the payload does not have class type.

Definition at line 365 of file Type.h.

m_size

size_t RootUtils::Type::m_size

private

The size in bytes of an instance of the described type.

Definition at line 358 of file Type.h.

m_ti

const std::type_info* RootUtils::Type::m_ti

private

The type_info for the described type.

Definition at line 355 of file Type.h.

m_type

EDataType RootUtils::Type::m_type

private

The ROOT type code of the derived type, or kNoType_t for a class type.

Definition at line 352 of file Type.h.

---

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

• Type.h
• Type.cxx