@Override public void exportDataSources() throws MalformedObjectNameException, MBeanRegistrationException, InstanceAlreadyExistsException, NotCompliantMBeanException { for ( ServiceReference<DataSource> dataSource : dataSources ) { String name = dataSource.identity(); Module module = ( Module ) spi.moduleOf( dataSource ); EntityDescriptor descriptor = module.entityDescriptor( DataSourceConfiguration.class.getName() ); List<MBeanAttributeInfo> attributes = new ArrayList<MBeanAttributeInfo>(); Map<String, AccessibleObject> properties = new LinkedHashMap<String, AccessibleObject>(); for ( PropertyDescriptor persistentProperty : descriptor.state().properties() ) { if ( !persistentProperty.isImmutable() ) { String propertyName = persistentProperty.qualifiedName().name(); String type = persistentProperty.valueType().mainType().getName(); attributes.add( new MBeanAttributeInfo( propertyName, type, propertyName, true, true, type.equals( "java.lang.Boolean" ) ) ); properties.put( propertyName, persistentProperty.accessor() ); } } List<MBeanOperationInfo> operations = new ArrayList<MBeanOperationInfo>(); operations.add( new MBeanOperationInfo( "restart", "Restart DataSource", new MBeanParameterInfo[ 0 ], "void", MBeanOperationInfo.ACTION_INFO ) ); MBeanInfo mbeanInfo = new MBeanInfo( DataSourceConfiguration.class.getName(), name, attributes.toArray( new MBeanAttributeInfo[ attributes.size() ] ), null, operations.toArray( new MBeanOperationInfo[ operations.size() ] ), null ); Object mbean = new ConfigurableDataSource( dataSourceService, mbeanInfo, name, properties ); ObjectName configurableDataSourceName = new ObjectName( "Zest:application=" + application.name() + ",class=Datasource,name=" + name ); server.registerMBean( mbean, configurableDataSourceName ); configurationNames.add( configurableDataSourceName ); } }
private void indexEntityType( final EntityDescriptor entityType, final RepositoryConnection connection ) throws RepositoryException { if( entityType.queryable() ) { final URI compositeURI = getValueFactory().createURI( Classes.toURI(first( entityType.types() )) ); // remove composite type if already present connection.clear( compositeURI ); Iterable<Statement> statements = typeSerializer.serialize( entityType ); connection.add( statements, compositeURI ); } }
private void serializeMixinTypes( final EntityDescriptor entityDescriptor, final Graph graph, final URI entityTypeUri ) { ValueFactory values = graph.getValueFactory(); // Mixin types for( Class<?> mixinType : entityDescriptor.mixinTypes() ) { graph.add( entityTypeUri, Rdfs.SUB_CLASS_OF, values.createURI( Classes.toURI( mixinType ) ) ); } }
public void serialize( final EntityState entityState, final boolean includeNonQueryable, final Graph graph ) { ValueFactory values = graph.getValueFactory(); EntityReference identity = entityState.identity(); URI entityUri = createEntityURI( values, identity ); graph.add( entityUri, Rdfs.TYPE, values.createURI( Classes.toURI( first( entityState.entityDescriptor().types() ) ) ) ); serializeProperties( entityState, graph, entityUri, entityState.entityDescriptor(), includeNonQueryable ); serializeAssociations( entityState, graph, entityUri, entityState.entityDescriptor().state().associations(), includeNonQueryable ); serializeManyAssociations( entityState, graph, entityUri, entityState.entityDescriptor().state().manyAssociations(), includeNonQueryable ); }
Class<?> type = first( descriptor.types() ); rows.add( new TableRow( 2, nameRow, type.getSimpleName() ) ); rows.add( new TableRow( 2, classRow, type.getName() ) ); rows.add( new TableRow( 2, visibilityRow, descriptor.visibility().toString() ) ); rows.add( new TableRow( 2, moduleRow, ( (EntityDetailDescriptor) objectDesciptor ).module() ) ); rows.add( new TableRow( 2, layerRow, ( (EntityDetailDescriptor) objectDesciptor ).module().layer() ) );
compositeUri = context.createCompositeUri( moduleUri, first( entityDescriptor.types() ) ); context.addType( compositeUri, Qi4jRdf.TYPE_ENTITY ); context.addRelationship( moduleUri, Qi4jRdf.RELATIONSHIP_ENTITY, compositeUri );
private void indexEntityState( final EntityState entityState, final RepositoryConnection connection ) throws RepositoryException { if( entityState.entityDescriptor().queryable() ) { final URI entityURI = stateSerializer.createEntityURI( getValueFactory(), entityState.identity() ); Graph graph = new GraphImpl(); stateSerializer.serialize( entityState, false, graph ); connection.add( graph, entityURI ); } }
writeString( "- name: " + descriptor.toString() ); writeString( "- class: " + descriptor.toString() ); writeString( "- visibility: " + descriptor.visibility().toString() );
private void serializeProperties( final EntityState entityState, final Graph graph, final Resource subject, final EntityDescriptor entityType, final boolean includeNonQueryable ) { // Properties for( PropertyDescriptor persistentProperty : entityType.state().properties() ) { Object property = entityState.propertyValueOf( persistentProperty.qualifiedName() ); if( property != null ) { serializeProperty( persistentProperty, property, subject, graph, includeNonQueryable ); } } }
public Iterable<Statement> serialize( final EntityDescriptor entityDescriptor ) { Graph graph = new GraphImpl(); ValueFactory values = graph.getValueFactory(); URI entityTypeUri = values.createURI( Classes.toURI( first( entityDescriptor.types() ) ) ); graph.add( entityTypeUri, Rdfs.TYPE, Rdfs.CLASS ); graph.add( entityTypeUri, Rdfs.TYPE, OWL.CLASS ); graph.add( entityTypeUri, Qi4jEntityType.TYPE, values.createLiteral( first( entityDescriptor.types() ).toString() ) ); graph.add( entityTypeUri, Qi4jEntityType.QUERYABLE, values.createLiteral( entityDescriptor.queryable() ) ); serializeMixinTypes( entityDescriptor, graph, entityTypeUri ); serializePropertyTypes( entityDescriptor, graph, entityTypeUri ); serializeAssociationTypes( entityDescriptor, graph, entityTypeUri ); serializeManyAssociationTypes( entityDescriptor, graph, entityTypeUri ); return graph; }
@Override public Map<String, EntityReference> map( AssociationDescriptor descriptor ) { AssociationDescriptor associationDescriptor; try { String associationName = descriptor.qualifiedName().name(); AssociationStateDescriptor entityState = entityDescriptor.state(); associationDescriptor = entityState.getNamedAssociationByName( associationName ); } catch( IllegalArgumentException e ) { return Collections.emptyMap(); } AccessibleObject associationMethod = associationDescriptor.accessor(); NamedAssociation<Object> assoc = associationState.namedAssociationFor( associationMethod ); Map<String, EntityReference> refs = new LinkedHashMap<>( assoc.count() ); for( String name : assoc ) { refs.put( name, EntityReference.entityReferenceFor( assoc.get( name ) ) ); } return refs; } } );
@Override public Iterable<EntityReference> map( final AssociationDescriptor descriptor ) { AssociationDescriptor associationDescriptor; try { String associationName = descriptor.qualifiedName().name(); AssociationStateDescriptor entityState = entityDescriptor.state(); associationDescriptor = entityState.getManyAssociationByName( associationName ); } catch( IllegalArgumentException e ) { return Iterables.empty(); } ManyAssociation<?> state = associationState.manyAssociationFor( associationDescriptor.accessor() ); List<EntityReference> refs = new ArrayList<>( state.count() ); for( Object entity : state ) { refs.add( EntityReference.entityReferenceFor( entity ) ); } return refs; } },
private void serializePropertyTypes( final EntityDescriptor entityDescriptor, final Graph graph, final URI entityTypeUri ) { ValueFactory values = graph.getValueFactory(); // Properties for( PropertyDescriptor persistentProperty : entityDescriptor.state().properties() ) { URI propertyURI = values.createURI( persistentProperty.qualifiedName().toURI() ); graph.add( propertyURI, Rdfs.DOMAIN, entityTypeUri ); graph.add( propertyURI, Rdfs.TYPE, Rdfs.PROPERTY ); // TODO Support more types URI type = dataTypes.get( persistentProperty.valueType().mainType().getName() ); if( type != null ) { graph.add( propertyURI, Rdfs.RANGE, type ); } } } }
@Override public EntityReference map( AssociationDescriptor descriptor ) { AssociationDescriptor associationDescriptor; try { associationDescriptor = entityDescriptor.state() .getAssociationByName( descriptor.qualifiedName().name() ); } catch( IllegalArgumentException e ) { return null; } AccessibleObject associationMethod = associationDescriptor.accessor(); Association<Object> association = associationState.associationFor( associationMethod ); return EntityReference.entityReferenceFor( association.get() ); } },
@Override public void update( Object entity, Object value ) throws NoSuchEntityException { EntityComposite eComposite = (EntityComposite) entity; ValueComposite vComposite = (ValueComposite) value; EntityDescriptor eDesc = spi.entityDescriptorFor( eComposite ); AssociationStateHolder eState = spi.stateOf( eComposite ); AssociationStateDescriptor eStateDesc = eDesc.state(); ValueDescriptor vDesc = spi.valueDescriptorFor( vComposite ); AssociationStateHolder vState = spi.stateOf( vComposite ); AssociationStateDescriptor vStateDesc = vDesc.state(); Unqualified unqualified = vDesc.metaInfo( Unqualified.class ); if( unqualified == null || !unqualified.value() ) { doQualifiedUpdate( eState, eStateDesc, vState, vStateDesc ); } else { doUnQualifiedUpdate( eState, eStateDesc, vState, vStateDesc ); } }
private void serializeManyAssociationTypes( final EntityDescriptor entityDescriptor, final Graph graph, final URI entityTypeUri ) { ValueFactory values = graph.getValueFactory(); // ManyAssociations for( AssociationDescriptor manyAssociationType : entityDescriptor.state().manyAssociations() ) { URI associationURI = values.createURI( manyAssociationType.qualifiedName().toURI() ); graph.add( associationURI, Rdfs.DOMAIN, entityTypeUri ); graph.add( associationURI, Rdfs.TYPE, Rdfs.SEQ ); URI associatedURI = values.createURI( manyAssociationType.qualifiedName().toURI() ); graph.add( associationURI, Rdfs.RANGE, associatedURI ); graph.add( associationURI, Rdfs.RANGE, XMLSchema.ANYURI ); } }
private void serializeAssociationTypes( final EntityDescriptor entityDescriptor, final Graph graph, final URI entityTypeUri ) { ValueFactory values = graph.getValueFactory(); // Associations for( AssociationDescriptor associationType : entityDescriptor.state().associations() ) { URI associationURI = values.createURI( associationType.qualifiedName().toURI() ); graph.add( associationURI, Rdfs.DOMAIN, entityTypeUri ); graph.add( associationURI, Rdfs.TYPE, Rdfs.PROPERTY ); URI associatedURI = values.createURI( Classes.toURI( Classes.RAW_CLASS.map( associationType.type() ) ) ); graph.add( associationURI, Rdfs.RANGE, associatedURI ); graph.add( associationURI, Rdfs.RANGE, XMLSchema.ANYURI ); } }
AssociationStateDescriptor entityState = entityDescriptor.state(); String associationName = descriptor.qualifiedName().name(); if( STRING_TYPE_SPEC.satisfiedBy( descriptor.valueType() ) )
@Override public Object map( final PropertyDescriptor descriptor ) AssociationStateDescriptor entityState = entityDescriptor.state(); String propertyName = descriptor.qualifiedName().name(); try