@Ecore(
    nsURI='',
    nsPrefix='anchor')
@GenModel(
    modelName='Anchor',
    prefix='Anchor',
    modelDirectory='target/generated-sources/xcore')

annotation "http://www.eclipse.org/emf/2002/Ecore" as Ecore
annotation "http://www.eclipse.org/emf/2002/GenModel" as GenModel

class AnchorModel extends NamedElement {
    contains Anchor[] anchors opposite model
    contains Tie[] ties opposite model
    contains Knot[] knots opposite model
}

class Anchor extends NamedElement {
    container AnchorModel[1] model opposite anchors
    contains Attribute[] attributes opposite anchor
}

interface HistorizedElement {
    contains DataTypeBase[?] dateTimeType
}

abstract class Attribute extends NamedElement, HistorizedElement {
    container Anchor[1] anchor opposite attributes
}

class TypedAttribute extends Attribute, TypedElement {
}

class KnottedAttribute extends Attribute {
    refers Knot[1] knot
}

class Tie extends NamedElement, HistorizedElement {
    container AnchorModel[1] model opposite ties
    contains AnchorRole[2..*] anchorRoles opposite tie
    contains KnotRole[] knotRoles opposite tie
}

class AnchorRole extends NamedElement {
    container Tie[1] tie opposite anchorRoles
    refers Anchor[1] anchor
}

class KnotRole extends NamedElement {
    container Tie[1] tie opposite knotRoles
    refers Knot[1] knot
}

class Knot extends NamedElement, TypedElement {
    container AnchorModel[1] model opposite knots
}

public class AnchorToDtoMapper {

    public static final AnchorToDtoMapper INSTANCE = new AnchorToDtoMapper();
    private static final String UNSUPPORTED = "Unsupported mapping for %s";

    private AnchorToDtoMapper() {
    }

    public AnchorModelDto map(final AnchorModel obj, final Map<java.lang.Class<?>, Object> imports) {
        final AnchorModelDto result = new AnchorModelDto();
        initAnchorModel(result, obj, imports);
        return result;
    }
    
    public void initAnchorModel(final AnchorModelDto result, final AnchorModel obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        result.getAnchors().addAll(obj.getAnchors().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
        result.getTies().addAll(obj.getTies().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
        result.getKnots().addAll(obj.getKnots().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
    }

    public AnchorDto map(final Anchor obj, final Map<java.lang.Class<?>, Object> imports) {
        final AnchorDto result = new AnchorDto();
        initAnchor(result, obj, imports);
        return result;
    }
    
    public void initAnchor(final AnchorDto result, final Anchor obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        result.getAttributes().addAll(obj.getAttributes().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
    }

    public AttributeDto map(final Attribute obj, final Map<java.lang.Class<?>, Object> imports) {
        if (obj instanceof TypedAttribute) {
            return map((TypedAttribute) obj, imports);
        }
        if (obj instanceof KnottedAttribute) {
            return map((KnottedAttribute) obj, imports);
        }
        for (Entry<java.lang.Class<?>, Object> mapperImport : imports.entrySet()) {
            java.lang.Class<?> objClass = mapperImport.getKey();
            Object mapper = mapperImport.getValue();
            if (objClass.isInstance(obj)) {
                try {
                    return (AttributeDto) mapper.getClass()
                            .getMethod("map", objClass, Map.class)
                            .invoke(mapper, obj, imports);
                }
                catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
        throw new UnsupportedOperationException(
                String.format(UNSUPPORTED, obj.getClass().getName()));
    }
    
    public void initAttribute(final AttributeDto result, final Attribute obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        if (obj.getDateTimeType() != null) {
            result.setDateTimeType(DataModelToDtoMapper.INSTANCE.map(obj.getDateTimeType(), imports));
        }
    }

    public TypedAttributeDto map(final TypedAttribute obj, final Map<java.lang.Class<?>, Object> imports) {
        final TypedAttributeDto result = new TypedAttributeDto();
        initTypedAttribute(result, obj, imports);
        return result;
    }
    
    public void initTypedAttribute(final TypedAttributeDto result, final TypedAttribute obj,
            final Map<java.lang.Class<?>, Object> imports) {
        initAttribute(result, obj, imports);
        if (obj.getDataType() != null) {
            result.setDataType(DataModelToDtoMapper.INSTANCE.map(obj.getDataType(), imports));
        }
    }

    public KnottedAttributeDto map(final KnottedAttribute obj, final Map<java.lang.Class<?>, Object> imports) {
        final KnottedAttributeDto result = new KnottedAttributeDto();
        initKnottedAttribute(result, obj, imports);
        return result;
    }
    
    public void initKnottedAttribute(final KnottedAttributeDto result, final KnottedAttribute obj,
            final Map<java.lang.Class<?>, Object> imports) {
        initAttribute(result, obj, imports);
        if (obj.getKnot() != null) {
            result.setKnot(obj.getKnot().getId());
        }
    }

    public TieDto map(final Tie obj, final Map<java.lang.Class<?>, Object> imports) {
        final TieDto result = new TieDto();
        initTie(result, obj, imports);
        return result;
    }
    
    public void initTie(final TieDto result, final Tie obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        if (obj.getDateTimeType() != null) {
            result.setDateTimeType(DataModelToDtoMapper.INSTANCE.map(obj.getDateTimeType(), imports));
        }
        result.getAnchorRoles().addAll(obj.getAnchorRoles().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
        result.getKnotRoles().addAll(obj.getKnotRoles().stream().
                map(item -> map(item, imports)).
                collect(Collectors.toList()));
    }

    public AnchorRoleDto map(final AnchorRole obj, final Map<java.lang.Class<?>, Object> imports) {
        final AnchorRoleDto result = new AnchorRoleDto();
        initAnchorRole(result, obj, imports);
        return result;
    }
    
    public void initAnchorRole(final AnchorRoleDto result, final AnchorRole obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        if (obj.getAnchor() != null) {
            result.setAnchor(obj.getAnchor().getId());
        }
    }

    public KnotRoleDto map(final KnotRole obj, final Map<java.lang.Class<?>, Object> imports) {
        final KnotRoleDto result = new KnotRoleDto();
        initKnotRole(result, obj, imports);
        return result;
    }
    
    public void initKnotRole(final KnotRoleDto result, final KnotRole obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        if (obj.getKnot() != null) {
            result.setKnot(obj.getKnot().getId());
        }
    }

    public KnotDto map(final Knot obj, final Map<java.lang.Class<?>, Object> imports) {
        final KnotDto result = new KnotDto();
        initKnot(result, obj, imports);
        return result;
    }
    
    public void initKnot(final KnotDto result, final Knot obj,
            final Map<java.lang.Class<?>, Object> imports) {
        DataModelToDtoMapper.INSTANCE.initNamedElement(result, obj, imports);
        if (obj.getDataType() != null) {
            result.setDataType(DataModelToDtoMapper.INSTANCE.map(obj.getDataType(), imports));
        }
    }

}

public class DtoToAnchorMapper {

    public static final DtoToAnchorMapper INSTANCE = new DtoToAnchorMapper();
    private static final AnchorFactory factory = AnchorPackage.eINSTANCE.getAnchorFactory();
    private static final String UNSUPPORTED = "Unsupported mapping for %s";

    private DtoToAnchorMapper() {
    }

    private void initRefs(final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        for (SimpleImmutableEntry<Object, Object> mapping : trace.values()) {
            Object source = mapping.getKey();
            Object target = mapping.getValue();
            if (source instanceof AnchorModelDto) {
                initAnchorModelRefs((AnchorModel) target, (AnchorModelDto) source, trace);
            }
            if (source instanceof AnchorDto) {
                initAnchorRefs((Anchor) target, (AnchorDto) source, trace);
            }
            if (source instanceof AttributeDto) {
                initAttributeRefs((Attribute) target, (AttributeDto) source, trace);
            }
            if (source instanceof TypedAttributeDto) {
                initTypedAttributeRefs((TypedAttribute) target, (TypedAttributeDto) source, trace);
            }
            if (source instanceof KnottedAttributeDto) {
                initKnottedAttributeRefs((KnottedAttribute) target, (KnottedAttributeDto) source, trace);
            }
            if (source instanceof TieDto) {
                initTieRefs((Tie) target, (TieDto) source, trace);
            }
            if (source instanceof AnchorRoleDto) {
                initAnchorRoleRefs((AnchorRole) target, (AnchorRoleDto) source, trace);
            }
            if (source instanceof KnotRoleDto) {
                initKnotRoleRefs((KnotRole) target, (KnotRoleDto) source, trace);
            }
            if (source instanceof KnotDto) {
                initKnotRefs((Knot) target, (KnotDto) source, trace);
            }
        }
    }

    public AnchorModel map(final AnchorModelDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final AnchorModel result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public AnchorModel create(final AnchorModelDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final AnchorModel result = factory.createAnchorModel();
        trace.put(new SimpleImmutableEntry<String, Object>("AnchorModel", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initAnchorModel(result, obj, imports, trace);
        return result;
    }
    
    public void initAnchorModel(final AnchorModel result, final AnchorModelDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
        result.getAnchors().addAll(obj.getAnchors().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
        result.getTies().addAll(obj.getTies().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
        result.getKnots().addAll(obj.getKnots().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
    }
    
    public void initAnchorModelRefs(final AnchorModel result, final AnchorModelDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
    }

    public Anchor map(final AnchorDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final Anchor result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public Anchor create(final AnchorDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final Anchor result = factory.createAnchor();
        trace.put(new SimpleImmutableEntry<String, Object>("Anchor", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initAnchor(result, obj, imports, trace);
        return result;
    }
    
    public void initAnchor(final Anchor result, final AnchorDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
        result.getAttributes().addAll(obj.getAttributes().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
    }
    
    public void initAnchorRefs(final Anchor result, final AnchorDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
    }

    public Attribute map(final AttributeDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final Attribute result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public Attribute create(final AttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        if (obj instanceof TypedAttributeDto) {
            return create((TypedAttributeDto) obj, imports, trace);
        }
        if (obj instanceof KnottedAttributeDto) {
            return create((KnottedAttributeDto) obj, imports, trace);
        }
        for (Entry<java.lang.Class<?>, Object> mapperImport : imports.entrySet()) {
            java.lang.Class<?> objClass = mapperImport.getKey();
            Object mapper = mapperImport.getValue();
            if (objClass.isInstance(obj)) {
                try {
                    return (Attribute) mapper.getClass()
                            .getMethod("create", objClass, Map.class, Map.class)
                            .invoke(mapper, obj, imports, trace);
                }
                catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
        throw new UnsupportedOperationException(
                String.format(UNSUPPORTED, obj.getClass().getName()));
    }
    
    public void initAttribute(final Attribute result, final AttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
        if (obj.getDateTimeType() != null) {
            result.setDateTimeType(DtoToDataModelMapper.INSTANCE.create(obj.getDateTimeType(), imports, trace));
        }
    }
    
    public void initAttributeRefs(final Attribute result, final AttributeDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
    }

    public TypedAttribute map(final TypedAttributeDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final TypedAttribute result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public TypedAttribute create(final TypedAttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final TypedAttribute result = factory.createTypedAttribute();
        trace.put(new SimpleImmutableEntry<String, Object>("TypedAttribute", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initTypedAttribute(result, obj, imports, trace);
        return result;
    }
    
    public void initTypedAttribute(final TypedAttribute result, final TypedAttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        initAttribute(result, obj, imports, trace);
        if (obj.getDataType() != null) {
            result.setDataType(DtoToDataModelMapper.INSTANCE.create(obj.getDataType(), imports, trace));
        }
    }
    
    public void initTypedAttributeRefs(final TypedAttribute result, final TypedAttributeDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        initAttributeRefs(result, obj, trace);
    }

    public KnottedAttribute map(final KnottedAttributeDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final KnottedAttribute result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public KnottedAttribute create(final KnottedAttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final KnottedAttribute result = factory.createKnottedAttribute();
        trace.put(new SimpleImmutableEntry<String, Object>("KnottedAttribute", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initKnottedAttribute(result, obj, imports, trace);
        return result;
    }
    
    public void initKnottedAttribute(final KnottedAttribute result, final KnottedAttributeDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        initAttribute(result, obj, imports, trace);
    }
    
    public void initKnottedAttributeRefs(final KnottedAttribute result, final KnottedAttributeDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        initAttributeRefs(result, obj, trace);
        if (obj.getKnot() != null) {
            result.setKnot((Knot) trace.get(
                    new SimpleImmutableEntry<String, Object>("Knot", obj.getKnot())).getValue());
        }
    }

    public Tie map(final TieDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final Tie result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public Tie create(final TieDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final Tie result = factory.createTie();
        trace.put(new SimpleImmutableEntry<String, Object>("Tie", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initTie(result, obj, imports, trace);
        return result;
    }
    
    public void initTie(final Tie result, final TieDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
        if (obj.getDateTimeType() != null) {
            result.setDateTimeType(DtoToDataModelMapper.INSTANCE.create(obj.getDateTimeType(), imports, trace));
        }
        result.getAnchorRoles().addAll(obj.getAnchorRoles().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
        result.getKnotRoles().addAll(obj.getKnotRoles().stream().
                map(item -> create(item, imports, trace)).
                collect(Collectors.toList()));
    }
    
    public void initTieRefs(final Tie result, final TieDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
    }

    public AnchorRole map(final AnchorRoleDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final AnchorRole result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public AnchorRole create(final AnchorRoleDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final AnchorRole result = factory.createAnchorRole();
        trace.put(new SimpleImmutableEntry<String, Object>("AnchorRole", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initAnchorRole(result, obj, imports, trace);
        return result;
    }
    
    public void initAnchorRole(final AnchorRole result, final AnchorRoleDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
    }
    
    public void initAnchorRoleRefs(final AnchorRole result, final AnchorRoleDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
        if (obj.getAnchor() != null) {
            result.setAnchor((Anchor) trace.get(
                    new SimpleImmutableEntry<String, Object>("Anchor", obj.getAnchor())).getValue());
        }
    }

    public KnotRole map(final KnotRoleDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final KnotRole result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public KnotRole create(final KnotRoleDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final KnotRole result = factory.createKnotRole();
        trace.put(new SimpleImmutableEntry<String, Object>("KnotRole", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initKnotRole(result, obj, imports, trace);
        return result;
    }
    
    public void initKnotRole(final KnotRole result, final KnotRoleDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
    }
    
    public void initKnotRoleRefs(final KnotRole result, final KnotRoleDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
        if (obj.getKnot() != null) {
            result.setKnot((Knot) trace.get(
                    new SimpleImmutableEntry<String, Object>("Knot", obj.getKnot())).getValue());
        }
    }

    public Knot map(final KnotDto obj, final Map<java.lang.Class<?>, Object> imports) {
        final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace = new HashMap<>();
        final Knot result = create(obj, imports, trace);
        initRefs(trace);
        return result;
    }
    
    public Knot create(final KnotDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        final Knot result = factory.createKnot();
        trace.put(new SimpleImmutableEntry<String, Object>("Knot", obj.getId()),
                new SimpleImmutableEntry<Object, Object>(obj, result));
        initKnot(result, obj, imports, trace);
        return result;
    }
    
    public void initKnot(final Knot result, final KnotDto obj,
            final Map<java.lang.Class<?>, Object> imports,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElement(result, obj, imports, trace);
        if (obj.getDataType() != null) {
            result.setDataType(DtoToDataModelMapper.INSTANCE.create(obj.getDataType(), imports, trace));
        }
    }
    
    public void initKnotRefs(final Knot result, final KnotDto obj,
            final Map<SimpleImmutableEntry<String, Object>, SimpleImmutableEntry<Object, Object>> trace) {
        DtoToDataModelMapper.INSTANCE.initNamedElementRefs(result, obj, trace);
    }

}