EntityCodex support.
506002
@Override
  public <Q extends BaseProxy> AutoBean<Q> getBeanForPayload(final Splittable serializedProxyId) {
    final IdMessage ref =
        AutoBeanCodex.decode(MessageFactoryHolder.FACTORY, IdMessage.class, serializedProxyId).as();
    @SuppressWarnings("unchecked")
    final SimpleProxyId<Q> id = (SimpleProxyId<Q>) this.getId(ref);
    return this.getProxyForReturnPayloadGraph(id);
  }
322302
private void buildEntityFromCursor(Object entity, HashMap obj, EntityType entityType)
    {
        Iterator<Attribute> iter = entityType.getAttributes().iterator();
        while (iter.hasNext())
        {
            Attribute attribute = iter.next();
            Field field = (Field) attribute.getJavaMember();
            if (field.isAnnotationPresent(Id.class))
            {
                PropertyAccessorHelper.set(entity, field, obj.get(ID));
            }
            else
            {
                PropertyAccessorHelper.set(entity, field, obj.get(((AbstractAttribute) attribute).getJPAColumnName()));
            }

        }
    }
658169
protected void processOutlineCodeField(Integer entityID, Row row)
   {
      processField(row, "OC_FIELD_ID", entityID, row.getString("OC_NAME"));
   }
761667
private static void postProcessMetadata(IntermediateParseResults intermediateResults) {
    intermediateResults
        .getEntityTypes()
        .forEach(
            entityType -> {
              setDefaultLabel(entityType);

              // in case no lookup attributes were defined:
              // try to set own id attribute and own label attribute as lookup attributes
              if (Iterables.size(entityType.getLookupAttributes()) == 0) {
                setDefaultLookupAttributes(entityType, 0);
              }
            });
  }
819388
protected void initInputSource(WstxInputSource newInput, boolean isExt,
                                   String entityId)
        throws XMLStreamException
    {
        // Let's make sure new input will be read next time input is needed:
        mInputPtr = 0;
        mInputEnd = 0;
        /* Plus, reset the input location so that'll be accurate for
         * error reporting etc.
         */
        mInputTopDepth = mCurrDepth;

        // [WSTX-296]: Check for entity expansion depth against configurable limit
        int entityDepth = mInput.getEntityDepth() + 1;
        verifyLimit("Maximum entity expansion depth", mConfig.getMaxEntityDepth(), entityDepth);
        mInput = newInput;
        mInput.initInputLocation(this, mCurrDepth, entityDepth);

        /* 21-Feb-2006, TSa: Linefeeds are NOT normalized when expanding
         *   internal entities (XML, 2.11)
         */
        if (isExt) {
            mNormalizeLFs = true;
        } else {
            mNormalizeLFs = false;
        }
    }
807382
def db_for_write(self, model, **hints):
        """"""
        if model._meta.app_label in MS_apps:
            return model._meta.app_label
        # if is_warranty(model):
        #     return 'warranty'
        return None
842865
function(oSchema, sQTypeName) {
			var aEntitySet = [];

			for (var i = -1, oEntityContainer; (oEntityContainer = oSchema.entityContainer[++i]) !== undefined;) {
				for (var j = -1, oEntitySet; (oEntitySet = oEntityContainer.entitySet[++j]) !== undefined;) {
					if (oEntitySet.entityType == sQTypeName) {
						aEntitySet.push([ oEntityContainer, oEntitySet ]);
					}
				}
			}

			return aEntitySet;
		}
818993
private void checkJdbcSupport(DatabaseMetaData metaData) throws SQLException {

        if (_getGeneratedKeys && !metaData.supportsGetGeneratedKeys()) {
            throw new ControlException("The database does not support getGeneratedKeys.");
        }

        if (_batchUpdate && !metaData.supportsBatchUpdates()) {
            throw new ControlException("The database does not support batchUpdates.");
        }

        if (_scrollType != JdbcControl.ScrollType.DRIVER_DEFAULT
                && !metaData.supportsResultSetConcurrency(_scrollType.getType(), _scrollType.getConcurrencyType())) {
            throw new ControlException("The database does not support the ResultSet concurrecy type: " + _scrollType.toString());
        }

        if (_holdability != JdbcControl.HoldabilityType.DRIVER_DEFAULT
                && !metaData.supportsResultSetHoldability(_holdability.getHoldability())) {
            throw new ControlException("The database does not support the ResultSet holdability type: " + _holdability.toString());
        }
    }
496949
private void onInheritedProperty(TableInfo tableInfo, EntityType entityType)
    {
        String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();

        if (discrColumn != null)
        {
            ColumnInfo columnInfo = new ColumnInfo();
            columnInfo.setColumnName(discrColumn);
            columnInfo.setType(String.class);
            columnInfo.setIndexable(true);

            IndexInfo idxInfo = new IndexInfo(discrColumn);
            tableInfo.addColumnInfo(columnInfo);
            tableInfo.addToIndexedColumnList(idxInfo);
        }
    }
808927
private static void doEnhancement(CtClass cc, Version modelVersion) throws CannotCompileException,
        NotFoundException, ClassNotFoundException {
        CtClass inter = cp.get(OpenEngSBModel.class.getName());
        cc.addInterface(inter);
        addFields(cc);
        addGetOpenEngSBModelTail(cc);
        addSetOpenEngSBModelTail(cc);
        addRetrieveModelName(cc);
        addRetrieveModelVersion(cc, modelVersion);
        addOpenEngSBModelEntryMethod(cc);
        addRemoveOpenEngSBModelEntryMethod(cc);
        addRetrieveInternalModelId(cc);
        addRetrieveInternalModelTimestamp(cc);
        addRetrieveInternalModelVersion(cc);
        addToOpenEngSBModelValues(cc);
        addToOpenEngSBModelEntries(cc);
        cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
    }
280692
def compile_rich(cls, code, path=None, extra_args=None):
        """"""

        return {
            contract_name: {
                'code': '0x' + contract.get('bin_hex'),
                'info': {
                    'abiDefinition': contract.get('abi'),
                    'compilerVersion': cls.compiler_version(),
                    'developerDoc': contract.get('devdoc'),
                    'language': 'Solidity',
                    'languageVersion': '0',
                    'source': code,
                    'userDoc': contract.get('userdoc')
                },
            }
            for contract_name, contract
            in cls.combined(code, path=path, extra_args=extra_args)
        }
668529
private static void onViaEmbeddable(EntityType entityType, Attribute column, EntityMetadata m, Object entity,
            EmbeddableType embeddable, JsonObject jsonObj)
    {
        Field embeddedField = (Field) column.getJavaMember();
        JsonElement embeddedDocumentObject = jsonObj.get(((AbstractAttribute) column).getJPAColumnName());
        if (!column.isCollection())
        {
            PropertyAccessorHelper.set(
                    entity,
                    embeddedField,
                    getObjectFromJson(embeddedDocumentObject.getAsJsonObject(),
                            ((AbstractAttribute) column).getBindableJavaType(), embeddable.getAttributes()));
        }
    }
43175
@Override
	protected StringBuilder propertyResponse(NameValuePairMap vars,
			DBGPContextType context) throws UnsupportedEncodingException
	{
		StringBuilder sb = new StringBuilder();

		for (Entry<ILexNameToken, Value> e : vars.entrySet())
		{
			if (!e.getKey().getName().equals("self"))
			{ // This test makes the self not appear

				if (isDebugVisible(e.getValue()))
				{
					sb.append(propertyResponse(e.getKey(), e.getValue(), context));
				}
			}
		}

		return sb;
	}
219717
def handle_entityref(self, name):
        """"""
        char_code = html_entities.name2codepoint.get(name, None)
        if char_code is not None:
            try:
                self.result += unichr(char_code).encode("utf-8")
            except:
                return
640671
private ClientResponse getActionClientResponse(
            EntityActionOperation entityActionOperation) {
        entityActionOperation.setProxyData(createProxyData());
        Builder webResource = getResource(entityActionOperation.getUri())
                .queryParams(entityActionOperation.getQueryParameters())
                .accept(entityActionOperation.getAcceptType())
                .accept(MediaType.APPLICATION_XML_TYPE)
                .type(MediaType.APPLICATION_XML_TYPE);
        if (entityActionOperation.getRequestContents() != null) {
            webResource = webResource.entity(
                    entityActionOperation.getRequestContents(),
                    entityActionOperation.getContentType());
        }
        return webResource.method(entityActionOperation.getVerb(),
                ClientResponse.class);
    }
787216
def entity(ctx, debug, uncolorize, **kwargs):
    
    global PROVIDER_CONFIG

    if debug:
        log.basicConfig(level=log.DEBUG)
        log.getLogger("requests.packages.urllib3.connectionpool").setLevel(log.DEBUG)
    for (k, v) in kwargs.iteritems():
        if v:
            QUBELL[k] = v
    PROVIDER_CONFIG = {
        'configuration.provider': PROVIDER['provider_type'],
        'configuration.legacy-regions': PROVIDER['provider_region'],
        'configuration.endpoint-url': '',
        'configuration.legacy-security-group': '',
        'configuration.identity': PROVIDER['provider_identity'],
        'configuration.credential': PROVIDER['provider_credential']
    }

    class UserContext(object):
        def __init__(self):
            self.platform = None
            self.unauthenticated_platform = None
            self.colorize = not (uncolorize)

        def get_platform(self):
            if not self.platform:
                assert QUBELL["tenant"], "No platform URL provided. Set QUBELL_TENANT or use --tenant option."
                if not QUBELL["token"]:
                    assert QUBELL["user"], "No username. Set QUBELL_USER or use --user option."
                    assert QUBELL["password"], "No password provided. Set QUBELL_PASSWORD or use --password option."

                self.platform = QubellPlatform.connect(
                    tenant=QUBELL["tenant"],
                    user=QUBELL["user"],
                    password=QUBELL["password"],
                    token=QUBELL["token"])
            return self.platform

        def get_unauthenticated_platform(self):
            if not self.unauthenticated_platform:
                assert QUBELL["tenant"], "No platform URL provided. Set QUBELL_TENANT or use --tenant option."

                self.unauthenticated_platform = QubellPlatform.connect(tenant=QUBELL["tenant"])

            return self.unauthenticated_platform

    ctx = click.get_current_context()
    ctx.obj = UserContext()
931890
private static void generateEditor(PrefsEntity entity) {
		com.abubusoft.kripton.common.Converter<String, String> converter = CaseFormat.LOWER_CAMEL.converterTo(CaseFormat.UPPER_CAMEL);
		Builder innerClassBuilder = TypeSpec.classBuilder("BindEditor").addModifiers(Modifier.PUBLIC).addJavadoc("editor class for shared preferences\n").superclass(typeName("AbstractEditor"));
		innerClassBuilder.addMethod(MethodSpec.constructorBuilder().addModifiers(Modifier.PRIVATE).build());

		PrefsTransform transform;
		// write method
		for (PrefsProperty item : entity.getCollection()) {
			{ // put
				MethodSpec.Builder builder = MethodSpec.methodBuilder("put" + converter.convert(item.getName())).addModifiers(Modifier.PUBLIC).addParameter(typeName(item.getElement()), "value")
						.addJavadoc("modifier for property $L\n", item.getName()).returns(typeName("BindEditor"));

				TypeName type;
				if (item.hasTypeAdapter()) {
					type = typeName(item.typeAdapter.dataType);
				} else {
					type = TypeUtility.typeName(item.getElement());
				}

				transform = PrefsTransformer.lookup(type);
				transform.generateWriteProperty(builder, "editor", null, "value", item);
				builder.addCode("\n");

				builder.addStatement("return this");
				innerClassBuilder.addMethod(builder.build());
			}

			{ // remove
				MethodSpec.Builder builder = MethodSpec.methodBuilder("remove" + converter.convert(item.getName())).addModifiers(Modifier.PUBLIC).addJavadoc("remove property $L\n", item.getName())
						.returns(typeName("BindEditor"));

				builder.addStatement("editor.remove($S)", item.getPreferenceKey());

				builder.addStatement("return this");
				innerClassBuilder.addMethod(builder.build());
			}
		}

		{ // clear
			MethodSpec.Builder builder = MethodSpec.methodBuilder("clear").addModifiers(Modifier.PUBLIC).addJavadoc("clear all properties\n").returns(typeName("BindEditor"));

			builder.addStatement("editor.clear()");
			builder.addStatement("return this");
			innerClassBuilder.addMethod(builder.build());
		}

		builder.addType(innerClassBuilder.build());
	}