assimp.assimp/code/Importer/StepFile/StepFileGen2.cpp

/*
Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------

Copyright (c) 2006-2010, ASSIMP Development Team
All rights reserved.

Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

----------------------------------------------------------------------
*/

#include "code/Importer/StepFile/StepReaderGen.h"

namespace Assimp {
using namespace StepFile;
namespace STEP {

    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<classification_assignment>(const DB& db, const LIST& params, classification_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to classification_assignment"); }    do { // convert the 'assigned_class' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_class, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to classification_assignment to be a `group`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to classification_assignment to be a `classification_role`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_classification_assignment>(const DB& db, const LIST& params, applied_classification_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<classification_assignment*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_classification_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_classification_assignment to be a `SET [1:?] OF classification_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<contract_assignment>(const DB& db, const LIST& params, contract_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to contract_assignment"); }    do { // convert the 'assigned_contract' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::contract_assignment, 1>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_contract, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to contract_assignment to be a `contract`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_contract_assignment>(const DB& db, const LIST& params, applied_contract_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_contract_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_contract_assignment to be a `SET [1:?] OF contract_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<date_and_time_assignment>(const DB& db, const LIST& params, date_and_time_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_and_time_assignment"); }    do { // convert the 'assigned_date_and_time' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_date_and_time, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_and_time_assignment to be a `date_and_time`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_and_time_assignment to be a `date_time_role`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_date_and_time_assignment>(const DB& db, const LIST& params, applied_date_and_time_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_and_time_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_and_time_assignment to be a `SET [1:?] OF date_and_time_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<date_assignment>(const DB& db, const LIST& params, date_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_assignment"); }    do { // convert the 'assigned_date' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_date, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_assignment to be a `date`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_assignment to be a `date_role`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_date_assignment>(const DB& db, const LIST& params, applied_date_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<date_assignment*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_assignment to be a `SET [1:?] OF date_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<document_reference>(const DB& db, const LIST& params, document_reference* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_reference"); }    do { // convert the 'assigned_document' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_document, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_reference to be a `document`")); }
        } while (0);
        do { // convert the 'source' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->source, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_reference to be a `label`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_document_reference>(const DB& db, const LIST& params, applied_document_reference* in)
    {
        size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_reference"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_reference to be a `SET [1:?] OF document_reference_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<document_usage_constraint_assignment>(const DB& db, const LIST& params, document_usage_constraint_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_usage_constraint_assignment"); }    do { // convert the 'assigned_document_usage' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_document_usage, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_usage_constraint_assignment to be a `document_usage_constraint`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_usage_constraint_assignment to be a `document_usage_role`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_document_usage_constraint_assignment>(const DB& db, const LIST& params, applied_document_usage_constraint_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<document_usage_constraint_assignment*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_usage_constraint_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_usage_constraint_assignment to be a `SET [1:?] OF document_reference_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<effectivity_assignment>(const DB& db, const LIST& params, effectivity_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity_assignment"); }    do { // convert the 'assigned_effectivity' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_assignment, 1>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_effectivity, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_assignment to be a `effectivity`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_effectivity_assignment>(const DB& db, const LIST& params, applied_effectivity_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_effectivity_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_effectivity_assignment to be a `SET [1:?] OF effectivity_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<event_occurrence_assignment>(const DB& db, const LIST& params, event_occurrence_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to event_occurrence_assignment"); }    do { // convert the 'assigned_event_occurrence' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_event_occurrence, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence_assignment to be a `event_occurrence`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence_assignment to be a `event_occurrence_role`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<applied_event_occurrence_assignment>(const DB& db, const LIST& params, applied_event_occurrence_assignment* in)
    {
        size_t base = GenericFill(db, params, static_cast<event_occurrence_assignment*>(in));
        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_event_occurrence_assignment"); }    do { // convert the 'items' argument
            std::shared_ptr<const DataType> arg = params[base++];
            try { GenericConvert(in->items, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_event_occurrence_assignment to be a `SET [1:?] OF event_occurrence_item`")); }
        } while (0);
        return base;
    }
    // -----------------------------------------------------------------------------------------------------------
    template <> size_t GenericFill<identification_assignment>(const DB& db, const LIST& params, identification_assignment* in)
    {
        size_t base = 0;
        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to identification_assignment"); }    do { // convert the 'assigned_id' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[0] = true; break; }
            try { GenericConvert(in->assigned_id, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to identification_assignment to be a `identifier`")); }
        } while (0);
        do { // convert the 'role' argument
            std::shared_ptr<const DataType> arg = params[base++];
            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[1] = true; break; }
            try { GenericConvert(in->role, arg, db); break; }
            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to identification_assignment to be a `identification_role`")); }
        } while (0);
        return base;
    }
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<external_identification_assignment>(const DB& db, const LIST& params, external_identification_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to external_identification_assignment"); }    do { // convert the 'source' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_identification_assignment, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->source, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to external_identification_assignment to be a `external_source`")); }
    } while (0);
    return base;
}

// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_external_identification_assignment>(const DB& db, const LIST& params, applied_external_identification_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<external_identification_assignment*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_external_identification_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_external_identification_assignment to be a `SET [1:?] OF external_identification_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<group_assignment>(const DB& db, const LIST& params, group_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to group_assignment"); }    do { // convert the 'assigned_group' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group_assignment, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_group, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group_assignment to be a `group`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_group_assignment>(const DB& db, const LIST& params, applied_group_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_group_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_group_assignment to be a `SET [1:?] OF groupable_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_identification_assignment>(const DB& db, const LIST& params, applied_identification_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_identification_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_identification_assignment to be a `SET [1:?] OF identification_item`")); }
    } while (0);
    return base;
}

// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<name_assignment>(const DB& db, const LIST& params, name_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to name_assignment"); }    do { // convert the 'assigned_name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::name_assignment, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to name_assignment to be a `label`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_name_assignment>(const DB& db, const LIST& params, applied_name_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<name_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_name_assignment"); }    do { // convert the 'item' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->item, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_name_assignment to be a `name_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<organization_assignment>(const DB& db, const LIST& params, organization_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organization_assignment"); }    do { // convert the 'assigned_organization' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_organization, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organization_assignment to be a `organization`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organization_assignment to be a `organization_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_organization_assignment>(const DB& db, const LIST& params, applied_organization_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<organization_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organization_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organization_assignment to be a `SET [1:?] OF organization_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<organizational_project_assignment>(const DB& db, const LIST& params, organizational_project_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organizational_project_assignment"); }    do { // convert the 'assigned_organizational_project' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_organizational_project, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organizational_project_assignment to be a `organizational_project`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organizational_project_assignment to be a `organizational_project_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_organizational_project_assignment>(const DB& db, const LIST& params, applied_organizational_project_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<organizational_project_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organizational_project_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organizational_project_assignment to be a `SET [1:?] OF project_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<person_and_organization_assignment>(const DB& db, const LIST& params, person_and_organization_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to person_and_organization_assignment"); }    do { // convert the 'assigned_person_and_organization' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_person_and_organization, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to person_and_organization_assignment to be a `person_and_organization`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to person_and_organization_assignment to be a `person_and_organization_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_person_and_organization_assignment>(const DB& db, const LIST& params, applied_person_and_organization_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_person_and_organization_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_person_and_organization_assignment to be a `SET [1:?] OF person_and_organization_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<presented_item>(const DB& db, const LIST& params, presented_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_presented_item>(const DB& db, const LIST& params, applied_presented_item* in)
{
    size_t base = GenericFill(db, params, static_cast<presented_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to applied_presented_item"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to applied_presented_item to be a `SET [1:?] OF presented_item_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<security_classification_assignment>(const DB& db, const LIST& params, security_classification_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to security_classification_assignment"); }    do { // convert the 'assigned_security_classification' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::security_classification_assignment, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_security_classification, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to security_classification_assignment to be a `security_classification`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_security_classification_assignment>(const DB& db, const LIST& params, applied_security_classification_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_security_classification_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_security_classification_assignment to be a `SET [1:?] OF security_classification_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<time_interval_assignment>(const DB& db, const LIST& params, time_interval_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_assignment"); }    do { // convert the 'assigned_time_interval' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_time_interval, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval_assignment to be a `time_interval`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_assignment to be a `time_interval_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_time_interval_assignment>(const DB& db, const LIST& params, applied_time_interval_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<time_interval_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_time_interval_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_time_interval_assignment to be a `SET [0:?] OF time_interval_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<applied_usage_right>(const DB& db, const LIST& params, applied_usage_right* in)
{
    size_t base = GenericFill(db, params, static_cast<applied_action_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_usage_right"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<area_in_set>(const DB& db, const LIST& params, area_in_set* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_in_set"); }    do { // convert the 'area' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->area, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to area_in_set to be a `presentation_area`")); }
    } while (0);
    do { // convert the 'in_set' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->in_set, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to area_in_set to be a `presentation_set`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<area_measure_with_unit>(const DB& db, const LIST& params, area_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<area_unit>(const DB& db, const LIST& params, area_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to area_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_definition_relationship>(const DB& db, const LIST& params, product_definition_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_relationship"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_relationship to be a `identifier`")); }
    } while (0);
    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[2] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'relating_product_definition' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->relating_product_definition, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_relationship to be a `product_definition`")); }
    } while (0);
    do { // convert the 'related_product_definition' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[4] = true; break; }
        try { GenericConvert(in->related_product_definition, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_relationship to be a `product_definition`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_definition_usage>(const DB& db, const LIST& params, product_definition_usage* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_usage"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<assembly_component_usage>(const DB& db, const LIST& params, assembly_component_usage* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to assembly_component_usage"); }    do { // convert the 'reference_designator' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::assembly_component_usage, 1>::aux_is_derived[0] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->reference_designator, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to assembly_component_usage to be a `identifier`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<assigned_requirement>(const DB& db, const LIST& params, assigned_requirement* in)
{
    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to assigned_requirement"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to assigned_requirement to be a `SET [1:1] OF product_definition`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<compound_representation_item>(const DB& db, const LIST& params, compound_representation_item* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to compound_representation_item"); }    do { // convert the 'item_element' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::compound_representation_item, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->item_element, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to compound_representation_item to be a `compound_item_definition`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<atomic_formula>(const DB& db, const LIST& params, atomic_formula* in)
{
    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to atomic_formula"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<attribute_assertion>(const DB& db, const LIST& params, attribute_assertion* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<attribute_language_assignment>(const DB& db, const LIST& params, attribute_language_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to attribute_language_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to attribute_language_assignment to be a `SET [1:?] OF attribute_language_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<attribute_value_assignment>(const DB& db, const LIST& params, attribute_value_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_value_assignment"); }    do { // convert the 'attribute_name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->attribute_name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_value_assignment to be a `label`")); }
    } while (0);
    do { // convert the 'attribute_value' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->attribute_value, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_value_assignment to be a `attribute_type`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_value_assignment to be a `attribute_value_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<auxiliary_geometric_representation_item>(const DB& db, const LIST& params, auxiliary_geometric_representation_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<placement>(const DB& db, const LIST& params, placement* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to placement"); }    do { // convert the 'location' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::placement, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->location, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to placement to be a `cartesian_point`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<axis1_placement>(const DB& db, const LIST& params, axis1_placement* in)
{
    size_t base = GenericFill(db, params, static_cast<placement*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis1_placement"); }    do { // convert the 'axis' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->axis, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis1_placement to be a `direction`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<axis2_placement_2d>(const DB& db, const LIST& params, axis2_placement_2d* in)
{
    size_t base = GenericFill(db, params, static_cast<placement*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis2_placement_2d"); }    do { // convert the 'ref_direction' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->ref_direction, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_2d to be a `direction`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<axis2_placement_3d>(const DB& db, const LIST& params, axis2_placement_3d* in)
{
    size_t base = GenericFill(db, params, static_cast<placement*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to axis2_placement_3d"); }    do { // convert the 'axis' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->axis, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_3d to be a `direction`")); }
    } while (0);
    do { // convert the 'ref_direction' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->ref_direction, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to axis2_placement_3d to be a `direction`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve>(const DB& db, const LIST& params, curve* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to curve"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bounded_curve>(const DB& db, const LIST& params, bounded_curve* in)
{
    size_t base = GenericFill(db, params, static_cast<curve*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_curve"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<b_spline_curve>(const DB& db, const LIST& params, b_spline_curve* in)
{
    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to b_spline_curve"); }    do { // convert the 'degree' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->degree, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_curve to be a `INTEGER`")); }
    } while (0);
    do { // convert the 'control_points_list' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->control_points_list, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_curve to be a `LIST [2:?] OF cartesian_point`")); }
    } while (0);
    do { // convert the 'curve_form' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->curve_form, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_curve to be a `b_spline_curve_form`")); }
    } while (0);
    do { // convert the 'closed_curve' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->closed_curve, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_curve to be a `LOGICAL`")); }
    } while (0);
    do { // convert the 'self_intersect' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[4] = true; break; }
        try { GenericConvert(in->self_intersect, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_curve to be a `LOGICAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<b_spline_curve_with_knots>(const DB& db, const LIST& params, b_spline_curve_with_knots* in)
{
    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to b_spline_curve_with_knots"); }    do { // convert the 'knot_multiplicities' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->knot_multiplicities, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_curve_with_knots to be a `LIST [2:?] OF INTEGER`")); }
    } while (0);
    do { // convert the 'knots' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->knots, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_curve_with_knots to be a `LIST [2:?] OF parameter_value`")); }
    } while (0);
    do { // convert the 'knot_spec' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->knot_spec, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_curve_with_knots to be a `knot_type`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<surface>(const DB& db, const LIST& params, surface* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bounded_surface>(const DB& db, const LIST& params, bounded_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<surface*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_surface"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<b_spline_surface>(const DB& db, const LIST& params, b_spline_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to b_spline_surface"); }    do { // convert the 'u_degree' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->u_degree, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_surface to be a `INTEGER`")); }
    } while (0);
    do { // convert the 'v_degree' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->v_degree, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_surface to be a `INTEGER`")); }
    } while (0);
    do { // convert the 'surface_form' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->surface_form, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_surface to be a `b_spline_surface_form`")); }
    } while (0);
    do { // convert the 'u_closed' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->u_closed, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_surface to be a `LOGICAL`")); }
    } while (0);
    do { // convert the 'v_closed' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[4] = true; break; }
        try { GenericConvert(in->v_closed, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_surface to be a `LOGICAL`")); }
    } while (0);
    do { // convert the 'self_intersect' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[5] = true; break; }
        try { GenericConvert(in->self_intersect, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_surface to be a `LOGICAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<b_spline_surface_with_knots>(const DB& db, const LIST& params, b_spline_surface_with_knots* in)
{
    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
    if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to b_spline_surface_with_knots"); }    do { // convert the 'u_multiplicities' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->u_multiplicities, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
    } while (0);
    do { // convert the 'v_multiplicities' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->v_multiplicities, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
    } while (0);
    do { // convert the 'u_knots' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->u_knots, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
    } while (0);
    do { // convert the 'v_knots' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->v_knots, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
    } while (0);
    do { // convert the 'knot_spec' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->knot_spec, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to b_spline_surface_with_knots to be a `knot_type`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_definition>(const DB& db, const LIST& params, product_definition* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition to be a `identifier`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition to be a `text`")); }
    } while (0);
    do { // convert the 'formation' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->formation, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition to be a `product_definition_formation`")); }
    } while (0);
    do { // convert the 'frame_of_reference' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->frame_of_reference, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition to be a `product_definition_context`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<rule_software_definition>(const DB& db, const LIST& params, rule_software_definition* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_software_definition"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<rule_definition>(const DB& db, const LIST& params, rule_definition* in)
{
    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_definition"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<back_chaining_rule>(const DB& db, const LIST& params, back_chaining_rule* in)
{
    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to back_chaining_rule"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<back_chaining_rule_body>(const DB& db, const LIST& params, back_chaining_rule_body* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<colour>(const DB& db, const LIST& params, colour* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<background_colour>(const DB& db, const LIST& params, background_colour* in)
{
    size_t base = GenericFill(db, params, static_cast<colour*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to background_colour"); }    do { // convert the 'presentation' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->presentation, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to background_colour to be a `area_or_view`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<beveled_sheet_representation>(const DB& db, const LIST& params, beveled_sheet_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to beveled_sheet_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bezier_curve>(const DB& db, const LIST& params, bezier_curve* in)
{
    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to bezier_curve"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bezier_surface>(const DB& db, const LIST& params, bezier_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to bezier_surface"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<generic_expression>(const DB& db, const LIST& params, generic_expression* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<binary_generic_expression>(const DB& db, const LIST& params, binary_generic_expression* in)
{
    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to binary_generic_expression"); }    do { // convert the 'operands' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->operands, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to binary_generic_expression to be a `LIST [2:2] OF generic_expression`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<binary_numeric_expression>(const DB& db, const LIST& params, binary_numeric_expression* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<binary_representation_item>(const DB& db, const LIST& params, binary_representation_item* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to binary_representation_item"); }    do { // convert the 'binary_value' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::binary_representation_item, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->binary_value, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to binary_representation_item to be a `BINARY`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<block>(const DB& db, const LIST& params, block* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to block"); }    do { // convert the 'position' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->position, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to block to be a `axis2_placement_3d`")); }
    } while (0);
    do { // convert the 'x' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->x, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to block to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'y' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->y, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to block to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'z' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->z, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to block to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<expression>(const DB& db, const LIST& params, expression* in)
{
    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boolean_expression>(const DB& db, const LIST& params, boolean_expression* in)
{
    size_t base = GenericFill(db, params, static_cast<expression*>(in));
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boolean_literal>(const DB& db, const LIST& params, boolean_literal* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to boolean_literal"); }    do { // convert the 'the_value' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->the_value, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to boolean_literal to be a `BOOLEAN`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boolean_representation_item>(const DB& db, const LIST& params, boolean_representation_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boolean_result>(const DB& db, const LIST& params, boolean_result* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boolean_result"); }    do { // convert the 'operator' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->operator_, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to boolean_result to be a `boolean_operator`")); }
    } while (0);
    do { // convert the 'first_operand' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->first_operand, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to boolean_result to be a `boolean_operand`")); }
    } while (0);
    do { // convert the 'second_operand' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->second_operand, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boolean_result to be a `boolean_operand`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_curve>(const DB& db, const LIST& params, composite_curve* in)
{
    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve"); }    do { // convert the 'segments' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->segments, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve to be a `LIST [1:?] OF composite_curve_segment`")); }
    } while (0);
    do { // convert the 'self_intersect' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->self_intersect, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve to be a `LOGICAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_curve_on_surface>(const DB& db, const LIST& params, composite_curve_on_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_curve*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_on_surface"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boundary_curve>(const DB& db, const LIST& params, boundary_curve* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_curve_on_surface*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to boundary_curve"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bounded_pcurve>(const DB& db, const LIST& params, bounded_pcurve* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bounded_surface_curve>(const DB& db, const LIST& params, bounded_surface_curve* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<founded_item>(const DB& db, const LIST& params, founded_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<box_domain>(const DB& db, const LIST& params, box_domain* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to box_domain"); }    do { // convert the 'corner' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->corner, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to box_domain to be a `cartesian_point`")); }
    } while (0);
    do { // convert the 'xlength' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->xlength, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to box_domain to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'ylength' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->ylength, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to box_domain to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'zlength' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->zlength, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to box_domain to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<half_space_solid>(const DB& db, const LIST& params, half_space_solid* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to half_space_solid"); }    do { // convert the 'base_surface' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->base_surface, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to half_space_solid to be a `surface`")); }
    } while (0);
    do { // convert the 'agreement_flag' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->agreement_flag, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to half_space_solid to be a `BOOLEAN`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<boxed_half_space>(const DB& db, const LIST& params, boxed_half_space* in)
{
    size_t base = GenericFill(db, params, static_cast<half_space_solid*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boxed_half_space"); }    do { // convert the 'enclosure' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->enclosure, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boxed_half_space to be a `box_domain`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<breakdown_context>(const DB& db, const LIST& params, breakdown_context* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_context"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<breakdown_element_group_assignment>(const DB& db, const LIST& params, breakdown_element_group_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to breakdown_element_group_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to breakdown_element_group_assignment to be a `SET [1:1] OF product_definition_or_breakdown_element_usage`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<breakdown_element_realization>(const DB& db, const LIST& params, breakdown_element_realization* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<breakdown_element_usage>(const DB& db, const LIST& params, breakdown_element_usage* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_element_usage"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<breakdown_of>(const DB& db, const LIST& params, breakdown_of* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_of"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<solid_model>(const DB& db, const LIST& params, solid_model* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_model"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<manifold_solid_brep>(const DB& db, const LIST& params, manifold_solid_brep* in)
{
    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to manifold_solid_brep"); }    do { // convert the 'outer' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::manifold_solid_brep, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->outer, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to manifold_solid_brep to be a `closed_shell`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<brep_with_voids>(const DB& db, const LIST& params, brep_with_voids* in)
{
    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to brep_with_voids"); }    do { // convert the 'voids' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->voids, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to brep_with_voids to be a `SET [1:?] OF oriented_closed_shell`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<bytes_representation_item>(const DB& db, const LIST& params, bytes_representation_item* in)
{
    size_t base = GenericFill(db, params, static_cast<binary_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to bytes_representation_item"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<date>(const DB& db, const LIST& params, date* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to date"); }    do { // convert the 'year_component' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->year_component, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date to be a `year_number`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<calendar_date>(const DB& db, const LIST& params, calendar_date* in)
{
    size_t base = GenericFill(db, params, static_cast<date*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to calendar_date"); }    do { // convert the 'day_component' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->day_component, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to calendar_date to be a `day_in_month_number`")); }
    } while (0);
    do { // convert the 'month_component' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->month_component, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to calendar_date to be a `month_in_year_number`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_image>(const DB& db, const LIST& params, camera_image* in)
{
    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_image_3d_with_scale>(const DB& db, const LIST& params, camera_image_3d_with_scale* in)
{
    size_t base = GenericFill(db, params, static_cast<camera_image*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image_3d_with_scale"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model>(const DB& db, const LIST& params, camera_model* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to camera_model"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_d3>(const DB& db, const LIST& params, camera_model_d3* in)
{
    size_t base = GenericFill(db, params, static_cast<camera_model*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_model_d3"); }    do { // convert the 'view_reference_system' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->view_reference_system, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3 to be a `axis2_placement_3d`")); }
    } while (0);
    do { // convert the 'perspective_of_volume' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->perspective_of_volume, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to camera_model_d3 to be a `view_volume`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_d3_multi_clipping>(const DB& db, const LIST& params, camera_model_d3_multi_clipping* in)
{
    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_multi_clipping"); }    do { // convert the 'shape_clipping' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->shape_clipping, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_multi_clipping to be a `SET [1:?] OF camera_model_d3_multi_clipping_interection_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_d3_multi_clipping_intersection>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_intersection* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_intersection"); }    do { // convert the 'shape_clipping' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->shape_clipping, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_intersection to be a `SET [2:?] OF camera_model_d3_multi_clipping_interection_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_d3_multi_clipping_union>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_union* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_union"); }    do { // convert the 'shape_clipping' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->shape_clipping, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_union to be a `SET [2:?] OF camera_model_d3_multi_clipping_union_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_d3_with_hlhsr>(const DB& db, const LIST& params, camera_model_d3_with_hlhsr* in)
{
    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_with_hlhsr"); }    do { // convert the 'hidden_line_surface_removal' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->hidden_line_surface_removal, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_with_hlhsr to be a `BOOLEAN`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_model_with_light_sources>(const DB& db, const LIST& params, camera_model_with_light_sources* in)
{
    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_with_light_sources"); }    do { // convert the 'sources' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->sources, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_with_light_sources to be a `SET [1:?] OF light_source`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<representation_map>(const DB& db, const LIST& params, representation_map* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_map"); }    do { // convert the 'mapping_origin' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->mapping_origin, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_map to be a `representation_item`")); }
    } while (0);
    do { // convert the 'mapped_representation' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->mapped_representation, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_map to be a `representation`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<camera_usage>(const DB& db, const LIST& params, camera_usage* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_usage"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<capacitance_measure_with_unit>(const DB& db, const LIST& params, capacitance_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to capacitance_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<capacitance_unit>(const DB& db, const LIST& params, capacitance_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to capacitance_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<point>(const DB& db, const LIST& params, point* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to point"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cartesian_point>(const DB& db, const LIST& params, cartesian_point* in)
{
    size_t base = GenericFill(db, params, static_cast<point*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cartesian_point"); }    do { // convert the 'coordinates' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->coordinates, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_point to be a `LIST [1:3] OF length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cartesian_transformation_operator>(const DB& db, const LIST& params, cartesian_transformation_operator* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator"); }    do { // convert the 'axis1' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[0] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->axis1, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to cartesian_transformation_operator to be a `direction`")); }
    } while (0);
    do { // convert the 'axis2' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->axis2, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_transformation_operator to be a `direction`")); }
    } while (0);
    do { // convert the 'local_origin' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->local_origin, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cartesian_transformation_operator to be a `cartesian_point`")); }
    } while (0);
    do { // convert the 'scale' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[3] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->scale, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to cartesian_transformation_operator to be a `REAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cartesian_transformation_operator_2d>(const DB& db, const LIST& params, cartesian_transformation_operator_2d* in)
{
    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator_2d"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cartesian_transformation_operator_3d>(const DB& db, const LIST& params, cartesian_transformation_operator_3d* in)
{
    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to cartesian_transformation_operator_3d"); }    do { // convert the 'axis3' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->axis3, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to cartesian_transformation_operator_3d to be a `direction`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_approval>(const DB& db, const LIST& params, cc_design_approval* in)
{
    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_approval"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_approval to be a `SET [1:?] OF approved_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_certification>(const DB& db, const LIST& params, cc_design_certification* in)
{
    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_certification"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_certification to be a `SET [1:?] OF certified_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_contract>(const DB& db, const LIST& params, cc_design_contract* in)
{
    size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_contract"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_contract to be a `SET [1:?] OF contracted_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_date_and_time_assignment>(const DB& db, const LIST& params, cc_design_date_and_time_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_date_and_time_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_date_and_time_assignment to be a `SET [1:?] OF date_time_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_person_and_organization_assignment>(const DB& db, const LIST& params, cc_design_person_and_organization_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_person_and_organization_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_person_and_organization_assignment to be a `SET [1:?] OF cc_person_organization_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_security_classification>(const DB& db, const LIST& params, cc_design_security_classification* in)
{
    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_security_classification"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_security_classification to be a `SET [1:?] OF cc_classified_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cc_design_specification_reference>(const DB& db, const LIST& params, cc_design_specification_reference* in)
{
    size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_specification_reference"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_specification_reference to be a `SET [1:?] OF cc_specified_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<celsius_temperature_measure_with_unit>(const DB& db, const LIST& params, celsius_temperature_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to celsius_temperature_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<centre_of_symmetry>(const DB& db, const LIST& params, centre_of_symmetry* in)
{
    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to centre_of_symmetry"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<change>(const DB& db, const LIST& params, change* in)
{
    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change to be a `SET [1:?] OF work_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<change_request>(const DB& db, const LIST& params, change_request* in)
{
    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change_request"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change_request to be a `SET [1:?] OF change_request_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<character_glyph_style_outline>(const DB& db, const LIST& params, character_glyph_style_outline* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_outline"); }    do { // convert the 'outline_style' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->outline_style, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_outline to be a `curve_style`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<character_glyph_style_stroke>(const DB& db, const LIST& params, character_glyph_style_stroke* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_stroke"); }    do { // convert the 'stroke_style' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->stroke_style, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_stroke to be a `curve_style`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<symbol_representation>(const DB& db, const LIST& params, symbol_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to symbol_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<generic_character_glyph_symbol>(const DB& db, const LIST& params, generic_character_glyph_symbol* in)
{
    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to generic_character_glyph_symbol"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<character_glyph_symbol>(const DB& db, const LIST& params, character_glyph_symbol* in)
{
    size_t base = GenericFill(db, params, static_cast<generic_character_glyph_symbol*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to character_glyph_symbol"); }    do { // convert the 'character_box' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->character_box, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to character_glyph_symbol to be a `planar_extent`")); }
    } while (0);
    do { // convert the 'baseline_ratio' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->baseline_ratio, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to character_glyph_symbol to be a `ratio_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<character_glyph_symbol_outline>(const DB& db, const LIST& params, character_glyph_symbol_outline* in)
{
    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_outline"); }    do { // convert the 'outlines' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->outlines, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_outline to be a `SET [1:?] OF annotation_fill_area`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<character_glyph_symbol_stroke>(const DB& db, const LIST& params, character_glyph_symbol_stroke* in)
{
    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_stroke"); }    do { // convert the 'strokes' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->strokes, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_stroke to be a `SET [1:?] OF curve`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<general_property>(const DB& db, const LIST& params, general_property* in)
{
    size_t base = 0;
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_property"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property to be a `identifier`")); }
    } while (0);
    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[2] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property to be a `text`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characteristic_data_column_header>(const DB& db, const LIST& params, characteristic_data_column_header* in)
{
    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_column_header"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<general_property_relationship>(const DB& db, const LIST& params, general_property_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to general_property_relationship"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'relating_property' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->relating_property, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property_relationship to be a `general_property`")); }
    } while (0);
    do { // convert the 'related_property' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->related_property, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to general_property_relationship to be a `general_property`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characteristic_data_column_header_link>(const DB& db, const LIST& params, characteristic_data_column_header_link* in)
{
    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_column_header_link"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characteristic_data_table_header>(const DB& db, const LIST& params, characteristic_data_table_header* in)
{
    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_table_header"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characteristic_data_table_header_decomposition>(const DB& db, const LIST& params, characteristic_data_table_header_decomposition* in)
{
    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_table_header_decomposition"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<group>(const DB& db, const LIST& params, group* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to group"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to group to be a `text`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characteristic_type>(const DB& db, const LIST& params, characteristic_type* in)
{
    size_t base = GenericFill(db, params, static_cast<group*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characteristic_type"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characterized_class>(const DB& db, const LIST& params, characterized_class* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<characterized_object>(const DB& db, const LIST& params, characterized_object* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characterized_object"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to characterized_object to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to characterized_object to be a `text`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conic>(const DB& db, const LIST& params, conic* in)
{
    size_t base = GenericFill(db, params, static_cast<curve*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conic"); }    do { // convert the 'position' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conic, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->position, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conic to be a `axis2_placement`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<circle>(const DB& db, const LIST& params, circle* in)
{
    size_t base = GenericFill(db, params, static_cast<conic*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to circle"); }    do { // convert the 'radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to circle to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<circular_runout_tolerance>(const DB& db, const LIST& params, circular_runout_tolerance* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to circular_runout_tolerance"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<class_by_extension>(const DB& db, const LIST& params, class_by_extension* in)
{
    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_extension"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<class_by_intension>(const DB& db, const LIST& params, class_by_intension* in)
{
    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_intension"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<class_system>(const DB& db, const LIST& params, class_system* in)
{
    size_t base = GenericFill(db, params, static_cast<group*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_system"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<effectivity_context_assignment>(const DB& db, const LIST& params, effectivity_context_assignment* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to effectivity_context_assignment"); }    do { // convert the 'assigned_effectivity_assignment' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->assigned_effectivity_assignment, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_context_assignment to be a `effectivity_assignment`")); }
    } while (0);
    do { // convert the 'role' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->role, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to effectivity_context_assignment to be a `effectivity_context_role`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<class_usage_effectivity_context_assignment>(const DB& db, const LIST& params, class_usage_effectivity_context_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to class_usage_effectivity_context_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to class_usage_effectivity_context_assignment to be a `SET [1:?] OF class_usage_effectivity_context_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<topological_representation_item>(const DB& db, const LIST& params, topological_representation_item* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to topological_representation_item"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<connected_face_set>(const DB& db, const LIST& params, connected_face_set* in)
{
    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_face_set"); }    do { // convert the 'cfs_faces' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::connected_face_set, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->cfs_faces, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_face_set to be a `SET [1:?] OF face`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<closed_shell>(const DB& db, const LIST& params, closed_shell* in)
{
    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to closed_shell"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<coaxiality_tolerance>(const DB& db, const LIST& params, coaxiality_tolerance* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to coaxiality_tolerance"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<colour_specification>(const DB& db, const LIST& params, colour_specification* in)
{
    size_t base = GenericFill(db, params, static_cast<colour*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to colour_specification"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::colour_specification, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to colour_specification to be a `label`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<colour_rgb>(const DB& db, const LIST& params, colour_rgb* in)
{
    size_t base = GenericFill(db, params, static_cast<colour_specification*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to colour_rgb"); }    do { // convert the 'red' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->red, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to colour_rgb to be a `REAL`")); }
    } while (0);
    do { // convert the 'green' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->green, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to colour_rgb to be a `REAL`")); }
    } while (0);
    do { // convert the 'blue' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->blue, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to colour_rgb to be a `REAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<common_datum>(const DB& db, const LIST& params, common_datum* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<comparison_expression>(const DB& db, const LIST& params, comparison_expression* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<complex_clause>(const DB& db, const LIST& params, complex_clause* in)
{
    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_clause"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<complex_conjunctive_clause>(const DB& db, const LIST& params, complex_conjunctive_clause* in)
{
    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_conjunctive_clause"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<complex_disjunctive_clause>(const DB& db, const LIST& params, complex_disjunctive_clause* in)
{
    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_disjunctive_clause"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<modified_solid>(const DB& db, const LIST& params, modified_solid* in)
{
    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to modified_solid"); }    do { // convert the 'rationale' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->rationale, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to modified_solid to be a `text`")); }
    } while (0);
    do { // convert the 'base_solid' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->base_solid, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to modified_solid to be a `base_solid_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<shelled_solid>(const DB& db, const LIST& params, shelled_solid* in)
{
    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to shelled_solid"); }    do { // convert the 'deleted_face_set' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->deleted_face_set, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shelled_solid to be a `SET [1:?] OF face_surface`")); }
    } while (0);
    do { // convert the 'thickness' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->thickness, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to shelled_solid to be a `length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<complex_shelled_solid>(const DB& db, const LIST& params, complex_shelled_solid* in)
{
    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to complex_shelled_solid"); }    do { // convert the 'thickness_list' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->thickness_list, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to complex_shelled_solid to be a `LIST [1:?] OF length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_assembly_definition>(const DB& db, const LIST& params, composite_assembly_definition* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_definition"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_assembly_sequence_definition>(const DB& db, const LIST& params, composite_assembly_sequence_definition* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_sequence_definition"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<laminate_table>(const DB& db, const LIST& params, laminate_table* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laminate_table"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<part_laminate_table>(const DB& db, const LIST& params, part_laminate_table* in)
{
    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to part_laminate_table"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_assembly_table>(const DB& db, const LIST& params, composite_assembly_table* in)
{
    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_table"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_curve_segment>(const DB& db, const LIST& params, composite_curve_segment* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_segment"); }    do { // convert the 'transition' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->transition, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to composite_curve_segment to be a `transition_code`")); }
    } while (0);
    do { // convert the 'same_sense' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->same_sense, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve_segment to be a `BOOLEAN`")); }
    } while (0);
    do { // convert the 'parent_curve' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->parent_curve, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve_segment to be a `curve`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<material_designation>(const DB& db, const LIST& params, material_designation* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to material_designation"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to material_designation to be a `label`")); }
    } while (0);
    do { // convert the 'definitions' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->definitions, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to material_designation to be a `SET [1:?] OF characterized_definition`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_material_designation>(const DB& db, const LIST& params, composite_material_designation* in)
{
    size_t base = GenericFill(db, params, static_cast<material_designation*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_material_designation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_shape_aspect>(const DB& db, const LIST& params, composite_shape_aspect* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_shape_aspect"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_sheet_representation>(const DB& db, const LIST& params, composite_sheet_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_sheet_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_text>(const DB& db, const LIST& params, composite_text* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_text"); }    do { // convert the 'collected_text' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_text, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->collected_text, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_text to be a `SET [2:?] OF text_or_character`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_text_with_associated_curves>(const DB& db, const LIST& params, composite_text_with_associated_curves* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_associated_curves"); }    do { // convert the 'associated_curves' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->associated_curves, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_associated_curves to be a `SET [1:?] OF curve`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_text_with_blanking_box>(const DB& db, const LIST& params, composite_text_with_blanking_box* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_blanking_box"); }    do { // convert the 'blanking' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->blanking, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_blanking_box to be a `planar_box`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_text_with_delineation>(const DB& db, const LIST& params, composite_text_with_delineation* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_delineation"); }    do { // convert the 'delineation' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->delineation, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_delineation to be a `text_delineation`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<composite_text_with_extent>(const DB& db, const LIST& params, composite_text_with_extent* in)
{
    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_extent"); }    do { // convert the 'extent' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->extent, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_extent to be a `planar_extent`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<compound_shape_representation>(const DB& db, const LIST& params, compound_shape_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to compound_shape_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<concentricity_tolerance>(const DB& db, const LIST& params, concentricity_tolerance* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concentricity_tolerance"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<concept_feature_relationship>(const DB& db, const LIST& params, concept_feature_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to concept_feature_relationship"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to concept_feature_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to concept_feature_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'relating_product_concept_feature' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->relating_product_concept_feature, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to concept_feature_relationship to be a `product_concept_feature`")); }
    } while (0);
    do { // convert the 'related_product_concept_feature' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->related_product_concept_feature, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to concept_feature_relationship to be a `product_concept_feature`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<concept_feature_relationship_with_condition>(const DB& db, const LIST& params, concept_feature_relationship_with_condition* in)
{
    size_t base = GenericFill(db, params, static_cast<concept_feature_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concept_feature_relationship_with_condition"); }    do { // convert the 'conditional_operator' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->conditional_operator, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to concept_feature_relationship_with_condition to be a `concept_feature_operator`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_concept_feature>(const DB& db, const LIST& params, product_concept_feature* in)
{
    size_t base = 0;
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_feature"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_concept_feature to be a `identifier`")); }
    } while (0);
    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[2] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_feature to be a `text`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conditional_concept_feature>(const DB& db, const LIST& params, conditional_concept_feature* in)
{
    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conditional_concept_feature"); }    do { // convert the 'condition' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conditional_concept_feature, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->condition, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conditional_concept_feature to be a `concept_feature_relationship_with_condition`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conductance_measure_with_unit>(const DB& db, const LIST& params, conductance_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conductance_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conductance_unit>(const DB& db, const LIST& params, conductance_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to conductance_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configuration_item>(const DB& db, const LIST& params, configuration_item* in)
{
    size_t base = 0;
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to configuration_item"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item to be a `identifier`")); }
    } while (0);
    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[2] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item to be a `text`")); }
    } while (0);
    do { // convert the 'item_concept' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->item_concept, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item to be a `product_concept`")); }
    } while (0);
    do { // convert the 'purpose' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[4] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->purpose, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to configuration_item to be a `label`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configurable_item>(const DB& db, const LIST& params, configurable_item* in)
{
    size_t base = GenericFill(db, params, static_cast<configuration_item*>(in));
    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to configurable_item"); }    do { // convert the 'item_concept_feature' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->item_concept_feature, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to configurable_item to be a `SET [1:?] OF product_concept_feature_association`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<effectivity>(const DB& db, const LIST& params, effectivity* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity"); }    do { // convert the 'id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity to be a `identifier`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_definition_effectivity>(const DB& db, const LIST& params, product_definition_effectivity* in)
{
    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_effectivity"); }    do { // convert the 'usage' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_effectivity, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->usage, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_effectivity to be a `product_definition_relationship`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configuration_effectivity>(const DB& db, const LIST& params, configuration_effectivity* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_effectivity*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configuration_effectivity"); }    do { // convert the 'configuration' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->configuration, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_effectivity to be a `configuration_design`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configuration_item_relationship>(const DB& db, const LIST& params, configuration_item_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_relationship"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'relating_configuration_item' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->relating_configuration_item, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item_relationship to be a `configuration_item`")); }
    } while (0);
    do { // convert the 'related_configuration_item' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->related_configuration_item, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item_relationship to be a `configuration_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configuration_item_hierarchical_relationship>(const DB& db, const LIST& params, configuration_item_hierarchical_relationship* in)
{
    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_hierarchical_relationship"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configuration_item_revision_sequence>(const DB& db, const LIST& params, configuration_item_revision_sequence* in)
{
    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_revision_sequence"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configured_effectivity_assignment>(const DB& db, const LIST& params, configured_effectivity_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to configured_effectivity_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configured_effectivity_assignment to be a `SET [1:?] OF configured_effectivity_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<configured_effectivity_context_assignment>(const DB& db, const LIST& params, configured_effectivity_context_assignment* in)
{
    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configured_effectivity_context_assignment"); }    do { // convert the 'items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configured_effectivity_context_assignment to be a `SET [1:?] OF configured_effectivity_context_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conical_stepped_hole_transition>(const DB& db, const LIST& params, conical_stepped_hole_transition* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_stepped_hole_transition"); }    do { // convert the 'transition_number' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->transition_number, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conical_stepped_hole_transition to be a `positive_integer`")); }
    } while (0);
    do { // convert the 'cone_apex_angle' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->cone_apex_angle, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_stepped_hole_transition to be a `plane_angle_measure`")); }
    } while (0);
    do { // convert the 'cone_base_radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->cone_base_radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_stepped_hole_transition to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<elementary_surface>(const DB& db, const LIST& params, elementary_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<surface*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to elementary_surface"); }    do { // convert the 'position' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::elementary_surface, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->position, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to elementary_surface to be a `axis2_placement_3d`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conical_surface>(const DB& db, const LIST& params, conical_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_surface"); }    do { // convert the 'radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_surface to be a `length_measure`")); }
    } while (0);
    do { // convert the 'semi_angle' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->semi_angle, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_surface to be a `plane_angle_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<connected_edge_set>(const DB& db, const LIST& params, connected_edge_set* in)
{
    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_edge_set"); }    do { // convert the 'ces_edges' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->ces_edges, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_edge_set to be a `SET [1:?] OF edge`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<connected_face_sub_set>(const DB& db, const LIST& params, connected_face_sub_set* in)
{
    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to connected_face_sub_set"); }    do { // convert the 'parent_face_set' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->parent_face_set, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to connected_face_sub_set to be a `connected_face_set`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<constructive_geometry_representation>(const DB& db, const LIST& params, constructive_geometry_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to constructive_geometry_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<representation_relationship>(const DB& db, const LIST& params, representation_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_relationship"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[1] = true; break; }
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'rep_1' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->rep_1, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_relationship to be a `representation`")); }
    } while (0);
    do { // convert the 'rep_2' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->rep_2, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_relationship to be a `representation`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<constructive_geometry_representation_relationship>(const DB& db, const LIST& params, constructive_geometry_representation_relationship* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to constructive_geometry_representation_relationship"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<contact_ratio_representation>(const DB& db, const LIST& params, contact_ratio_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to contact_ratio_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<invisibility>(const DB& db, const LIST& params, invisibility* in)
{
    size_t base = 0;
    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to invisibility"); }    do { // convert the 'invisible_items' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::invisibility, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->invisible_items, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to invisibility to be a `SET [1:?] OF invisible_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<context_dependent_invisibility>(const DB& db, const LIST& params, context_dependent_invisibility* in)
{
    size_t base = GenericFill(db, params, static_cast<invisibility*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_invisibility"); }    do { // convert the 'presentation_context' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->presentation_context, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_invisibility to be a `invisibility_context`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<over_riding_styled_item>(const DB& db, const LIST& params, over_riding_styled_item* in)
{
    size_t base = GenericFill(db, params, static_cast<styled_item*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to over_riding_styled_item"); }    do { // convert the 'over_ridden_style' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->over_ridden_style, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to over_riding_styled_item to be a `styled_item`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<context_dependent_over_riding_styled_item>(const DB& db, const LIST& params, context_dependent_over_riding_styled_item* in)
{
    size_t base = GenericFill(db, params, static_cast<over_riding_styled_item*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to context_dependent_over_riding_styled_item"); }    do { // convert the 'style_context' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->style_context, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to context_dependent_over_riding_styled_item to be a `LIST [1:?] OF style_context_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<context_dependent_unit>(const DB& db, const LIST& params, context_dependent_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_unit"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_unit, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_unit to be a `label`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<conversion_based_unit>(const DB& db, const LIST& params, conversion_based_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to conversion_based_unit"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conversion_based_unit to be a `label`")); }
    } while (0);
    do { // convert the 'conversion_factor' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->conversion_factor, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conversion_based_unit to be a `measure_with_unit`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<csg_shape_representation>(const DB& db, const LIST& params, csg_shape_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to csg_shape_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<csg_solid>(const DB& db, const LIST& params, csg_solid* in)
{
    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to csg_solid"); }    do { // convert the 'tree_root_expression' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->tree_root_expression, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to csg_solid to be a `csg_select`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<currency>(const DB& db, const LIST& params, currency* in)
{
    size_t base = GenericFill(db, params, static_cast<context_dependent_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<currency_measure_with_unit>(const DB& db, const LIST& params, currency_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_bounded_surface>(const DB& db, const LIST& params, curve_bounded_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_bounded_surface"); }    do { // convert the 'basis_surface' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->basis_surface, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_bounded_surface to be a `surface`")); }
    } while (0);
    do { // convert the 'boundaries' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->boundaries, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_bounded_surface to be a `SET [1:?] OF boundary_curve`")); }
    } while (0);
    do { // convert the 'implicit_outer' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->implicit_outer, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_bounded_surface to be a `BOOLEAN`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_dimension>(const DB& db, const LIST& params, curve_dimension* in)
{
    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_dimension"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_replica>(const DB& db, const LIST& params, curve_replica* in)
{
    size_t base = GenericFill(db, params, static_cast<curve*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_replica"); }    do { // convert the 'parent_curve' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->parent_curve, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_replica to be a `curve`")); }
    } while (0);
    do { // convert the 'transformation' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->transformation, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_replica to be a `cartesian_transformation_operator`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_style>(const DB& db, const LIST& params, curve_style* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_style"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style to be a `label`")); }
    } while (0);
    do { // convert the 'curve_font' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->curve_font, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style to be a `curve_font_or_scaled_curve_font_select`")); }
    } while (0);
    do { // convert the 'curve_width' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->curve_width, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style to be a `size_select`")); }
    } while (0);
    do { // convert the 'curve_colour' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->curve_colour, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_style to be a `colour`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_style_font>(const DB& db, const LIST& params, curve_style_font* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font to be a `label`")); }
    } while (0);
    do { // convert the 'pattern_list' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->pattern_list, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font to be a `LIST [1:?] OF curve_style_font_pattern`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_style_font_and_scaling>(const DB& db, const LIST& params, curve_style_font_and_scaling* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_style_font_and_scaling"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_and_scaling to be a `label`")); }
    } while (0);
    do { // convert the 'curve_font' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->curve_font, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_and_scaling to be a `curve_style_font_select`")); }
    } while (0);
    do { // convert the 'curve_font_scaling' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->curve_font_scaling, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style_font_and_scaling to be a `REAL`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_style_font_pattern>(const DB& db, const LIST& params, curve_style_font_pattern* in)
{
    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font_pattern"); }    do { // convert the 'visible_segment_length' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->visible_segment_length, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_pattern to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'invisible_segment_length' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->invisible_segment_length, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_pattern to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<curve_swept_solid_shape_representation>(const DB& db, const LIST& params, curve_swept_solid_shape_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_swept_solid_shape_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cylindrical_surface>(const DB& db, const LIST& params, cylindrical_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cylindrical_surface"); }    do { // convert the 'radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cylindrical_surface to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<cylindricity_tolerance>(const DB& db, const LIST& params, cylindricity_tolerance* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cylindricity_tolerance"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<date_representation_item>(const DB& db, const LIST& params, date_representation_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<date_time_representation_item>(const DB& db, const LIST& params, date_time_representation_item* in)
{
    size_t base = 0;
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<dated_effectivity>(const DB& db, const LIST& params, dated_effectivity* in)
{
    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dated_effectivity"); }    do { // convert the 'effectivity_end_date' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const UNSET*>(&*arg)) break;
        try { GenericConvert(in->effectivity_end_date, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
    } while (0);
    do { // convert the 'effectivity_start_date' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->effectivity_start_date, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum>(const DB& db, const LIST& params, datum* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum"); }    do { // convert the 'identification' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->identification, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum to be a `identifier`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum_feature>(const DB& db, const LIST& params, datum_feature* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to datum_feature"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum_feature_callout>(const DB& db, const LIST& params, datum_feature_callout* in)
{
    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_feature_callout"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum_reference>(const DB& db, const LIST& params, datum_reference* in)
{
    size_t base = 0;
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_reference"); }    do { // convert the 'precedence' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->precedence, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to datum_reference to be a `INTEGER`")); }
    } while (0);
    do { // convert the 'referenced_datum' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->referenced_datum, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to datum_reference to be a `datum`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum_target>(const DB& db, const LIST& params, datum_target* in)
{
    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum_target"); }    do { // convert the 'target_id' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_target, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->target_id, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum_target to be a `identifier`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<datum_target_callout>(const DB& db, const LIST& params, datum_target_callout* in)
{
    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_target_callout"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<default_tolerance_table>(const DB& db, const LIST& params, default_tolerance_table* in)
{
    size_t base = GenericFill(db, params, static_cast<representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to default_tolerance_table"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<default_tolerance_table_cell>(const DB& db, const LIST& params, default_tolerance_table_cell* in)
{
    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to default_tolerance_table_cell"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<defined_symbol>(const DB& db, const LIST& params, defined_symbol* in)
{
    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to defined_symbol"); }    do { // convert the 'definition' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->definition, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to defined_symbol to be a `defined_symbol_select`")); }
    } while (0);
    do { // convert the 'target' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->target, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to defined_symbol to be a `symbol_target`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<definitional_representation>(const DB& db, const LIST& params, definitional_representation* in)
{
    size_t base = GenericFill(db, params, static_cast<representation*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to definitional_representation"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<definitional_representation_relationship>(const DB& db, const LIST& params, definitional_representation_relationship* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<definitional_representation_relationship_with_same_context>(const DB& db, const LIST& params, definitional_representation_relationship_with_same_context* in)
{
    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship_with_same_context"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<degenerate_pcurve>(const DB& db, const LIST& params, degenerate_pcurve* in)
{
    size_t base = GenericFill(db, params, static_cast<point*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to degenerate_pcurve"); }    do { // convert the 'basis_surface' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->basis_surface, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to degenerate_pcurve to be a `surface`")); }
    } while (0);
    do { // convert the 'reference_to_curve' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->reference_to_curve, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to degenerate_pcurve to be a `definitional_representation`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<toroidal_surface>(const DB& db, const LIST& params, toroidal_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to toroidal_surface"); }    do { // convert the 'major_radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->major_radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to toroidal_surface to be a `positive_length_measure`")); }
    } while (0);
    do { // convert the 'minor_radius' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->minor_radius, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to toroidal_surface to be a `positive_length_measure`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<degenerate_toroidal_surface>(const DB& db, const LIST& params, degenerate_toroidal_surface* in)
{
    size_t base = GenericFill(db, params, static_cast<toroidal_surface*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to degenerate_toroidal_surface"); }    do { // convert the 'select_outer' argument
        std::shared_ptr<const DataType> arg = params[base++];
        try { GenericConvert(in->select_outer, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to degenerate_toroidal_surface to be a `BOOLEAN`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<descriptive_representation_item>(const DB& db, const LIST& params, descriptive_representation_item* in)
{
    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to descriptive_representation_item"); }    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::descriptive_representation_item, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to descriptive_representation_item to be a `text`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<product_definition_context>(const DB& db, const LIST& params, product_definition_context* in)
{
    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_context"); }    do { // convert the 'life_cycle_stage' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_context, 1>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->life_cycle_stage, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_context to be a `label`")); }
    } while (0);
    return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<design_context>(const DB& db, const LIST& params, design_context* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to design_context"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<design_make_from_relationship>(const DB& db, const LIST& params, design_make_from_relationship* in)
{
    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to design_make_from_relationship"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<diameter_dimension>(const DB& db, const LIST& params, diameter_dimension* in)
{
    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to diameter_dimension"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<ratio_measure_with_unit>(const DB& db, const LIST& params, ratio_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ratio_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<dielectric_constant_measure_with_unit>(const DB& db, const LIST& params, dielectric_constant_measure_with_unit* in)
{
    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dielectric_constant_measure_with_unit"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<dimension_callout>(const DB& db, const LIST& params, dimension_callout* in)
{
    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_callout"); }	return base;
}
// -----------------------------------------------------------------------------------------------------------
template <> size_t GenericFill<draughting_callout_relationship>(const DB& db, const LIST& params, draughting_callout_relationship* in)
{
    size_t base = 0;
    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draughting_callout_relationship"); }    do { // convert the 'name' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[0] = true; break; }
        try { GenericConvert(in->name, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to draughting_callout_relationship to be a `label`")); }
    } while (0);
    do { // convert the 'description' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[1] = true; break; }
        try { GenericConvert(in->description, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout_relationship to be a `text`")); }
    } while (0);
    do { // convert the 'relating_draughting_callout' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[2] = true; break; }
        try { GenericConvert(in->relating_draughting_callout, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to draughting_callout_relationship to be a `draughting_callout`")); }
    } while (0);
    do { // convert the 'related_draughting_callout' argument
        std::shared_ptr<const DataType> arg = params[base++];
        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[3] = true; break; }
        try { GenericConvert(in->related_draughting_callout, arg, db); break; }
        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to draughting_callout_relationship to be a `draughting_callout`")); }
    } while (0);
    return base;
}

}
}