ora::RelationalMapping Namespace Reference

Functions
void	_sizeInColumns (const edm::TypeWithDict &typ, size_t &sz, bool &hasDependencies)
void	_sizeInColumnsForCArray (const edm::TypeWithDict &typ, size_t &sz, bool &hasDependencies)
size_t	sizeInColumns (const edm::TypeWithDict &topLevelClassType)
std::pair< bool, size_t >	sizeInColumnsForCArray (const edm::TypeWithDict &arrayType)

Function Documentation

void ora::RelationalMapping::_sizeInColumns	(	const edm::TypeWithDict &	typ,
		size_t &	sz,
		bool &	hasDependencies
	)

Definition at line 32 of file RelationalMapping.cc.

References _sizeInColumnsForCArray(), edm::TypeWithDict::hasBase(), edm::TypeWithDict::isArray(), edm::MemberWithDict::isTransient(), ora::ClassUtils::isTypeAssociativeContainer(), ora::ClassUtils::isTypeNamedReference(), ora::ClassUtils::isTypeNonAssociativeContainer(), ora::ClassUtils::isTypeOraPointer(), ora::ClassUtils::isTypePrimitive(), ora::ClassUtils::isTypeUniqueReference(), ora::ClassUtils::resolvedType(), and edm::MemberWithDict::typeOf().

Referenced by _sizeInColumnsForCArray(), and sizeInColumns().

                                                              {
  // resolve possible typedef chains
  edm::TypeWithDict typ = ClassUtils::resolvedType( topLevelClassType );
  bool isOraPolyPointer = ora::ClassUtils::isTypeUniqueReference(typ);
  bool isPrimitive = ora::ClassUtils::isTypePrimitive( typ );

  // primitive and string
  if( isPrimitive || isOraPolyPointer || ora::ClassUtils::isTypeNamedReference( typ)) {
    ++sz;
  } else if (typ.isArray()){
    size_t arraySize = 0;
    _sizeInColumnsForCArray( typ,arraySize, hasDependencies );
    if( arraySize < MappingRules::MaxColumnsForInlineCArray ) sz += arraySize;
    else hasDependencies = true;
  } else if (typ == typeid(ora::Reference) ||
             typ.hasBase( edm::TypeWithDict( typeid(ora::Reference) ) )){
    sz += 2;
  } else {
  
    bool isContainer =  ora::ClassUtils::isTypeNonAssociativeContainer(typ) ||
      ora::ClassUtils::isTypeAssociativeContainer(typ);
    bool isOraPointer = ora::ClassUtils::isTypeOraPointer(typ);
    if( !isContainer && !isOraPointer ){
      
      // loop over the data members
      //-ap ignore for now:  typ.UpdateMembers();
      //std::vector<edm::TypeWithDict> carrays;
      edm::TypeDataMembers members(typ);
      for (auto const & member : members) {
        edm::MemberWithDict objMember(member);

        // Skip the transient ones
        if ( objMember.isTransient() ) continue;

        // Retrieve the field type
        edm::TypeWithDict objMemberType = objMember.typeOf();

        _sizeInColumns(objMemberType,sz, hasDependencies );
      }
    } else {
      hasDependencies = true;
    }    
  }
}

void ora::RelationalMapping::_sizeInColumnsForCArray	(	const edm::TypeWithDict &	typ,
		size_t &	sz,
		bool &	hasDependencies
	)

Definition at line 80 of file RelationalMapping.cc.

References _sizeInColumns(), ora::ClassUtils::arrayLength(), edm::TypeWithDict::isArray(), ora::ClassUtils::resolvedType(), and edm::TypeWithDict::toType().

Referenced by _sizeInColumns(), and sizeInColumnsForCArray().

                                                                      {
  // resolve possible typedef chains
  edm::TypeWithDict typ = ClassUtils::resolvedType( topLevelClassType );
  if( !typ.isArray()){
    return;
  }

  size_t arraySize = ClassUtils::arrayLength( typ );
  edm::TypeWithDict arrayType = typ.toType();
  size_t arrayElementSize = 0;
  _sizeInColumns(arrayType, arrayElementSize, hasDependencies);
  size_t totSize = arraySize*arrayElementSize;
  sz += totSize;
}

size_t ora::RelationalMapping::sizeInColumns

(

const edm::TypeWithDict &

topLevelClassType

)

Definition at line 15 of file RelationalMapping.cc.

References _sizeInColumns().

Referenced by ora::MappingGenerator::createNewDependentMapping(), and ora::MappingGenerator::createNewMapping().

                                                                            {
  size_t sz=0;
  bool hasDependencies = false;
  _sizeInColumns(topLevelClassType, sz, hasDependencies );
  return sz;
}

std::pair< bool, size_t > ora::RelationalMapping::sizeInColumnsForCArray

(

const edm::TypeWithDict &

arrayType

)

Definition at line 23 of file RelationalMapping.cc.

References _sizeInColumnsForCArray().

Referenced by ora::CArrayMapping::process().

                                                                                     {
  size_t sz=0;
  bool hasDependencies = false;
  _sizeInColumnsForCArray(topLevelClassType, sz, hasDependencies );
  return std::make_pair(hasDependencies,sz);
}