@Override public String map( PropertyDescriptor propertyDescriptor ) { return propertyDescriptor.qualifiedName().name(); } }, descriptor.state().properties() ).iterator() );
public void addDefaultTriples( String resultType ) { triples.add( new Triple( "?entityType", "rdfs:subClassOf", "<" + Classes.toURI( resultType ) + ">", false ) ); triples.add( new Triple( "?entity", "rdf:type", "?entityType", false ) ); triples.add( new Triple( "?entity", addNamespace( QualifiedName.fromClass( Identity.class, "identity" ).toNamespace() ) + ":identity", "?identity", false ) ); }
/** * Creates a QualifiedName instance from the Class and a given name. * <p> * This factory method converts the {@code type} to a {@link TypeName} and appends the given {@code name}. * * @param type The Class that is the base of the QualifiedName. * @param name The qualifier name which will be appended to the base name derived from the {@code type} argument. * * @return A QualifiedName instance representing the {@code type} and {@code name} arguments. * * @throws NullArgumentException if any of the two arguments are {@code null}, or if the name string is empty. */ public static QualifiedName fromClass( Class type, String name ) { return new QualifiedName( TypeName.nameOf( type ), name ); }
public Triple addTripleAssociation( AssociationFunction<?> associationReference, boolean optional ) { String subject = "?entity"; if( associationReference.traversedAssociation() != null ) { subject = addTripleAssociation( associationReference.traversedAssociation(), false ).value; } QualifiedName qualifiedName = QualifiedName.fromAccessor( associationReference.accessor() ); String prefix = addNamespace( qualifiedName.toNamespace() ); return addTriple( subject, prefix + ":" + qualifiedName.name(), optional ); }
if( IDENTITY_STATE_NAME.equals( ePropDesc.qualifiedName() ) ) PropertyDescriptor vPropDesc = vStateDesc.findPropertyModelByName( ePropDesc.qualifiedName().name() ); eState.propertyFor( ePropDesc.accessor() ).set( vState.propertyFor( vPropDesc.accessor() ).get() ); try AssociationDescriptor vAssocDesc = vStateDesc.getAssociationByName( eAssocDesc.qualifiedName().name() ); eAssoc.set( vState.associationFor( vAssocDesc.accessor() ).get() ); = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) ) = vStateDesc.getManyAssociationByName( eAssocDesc.qualifiedName().name() ); ManyAssociation<Object> vManyAss = vState.manyAssociationFor( vAssDesc.accessor() ); for( Object ass : eManyAssoc.toList() ) = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_COLLECTION_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) ) = vStateDesc.getNamedAssociationByName( eAssocDesc.qualifiedName().name() ); NamedAssociation<Object> vNamedAssoc = vState.namedAssociationFor( vAssocDesc.accessor() ); for( String assocName : Iterables.toList( eNamedAssoc ) ) = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_MAP_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) )
/** * Returns the URI of the QualifiedName. * * <p> * The URI is the {@link #toNamespace()} followed by the {@code name} component. * <p> * * @return the URI of the QualifiedName. * * @see #toNamespace() */ public String toURI() { return toNamespace() + name; }
/** * Creates a QualifiedName from a method. * <p> * This factory method will create a QualifiedName from the Method itself. * * </p> * * @param method Type method that returns a Property, for which the QualifiedName will be representing. * * @return A QualifiedName representing this method. * * @throws NullArgumentException If the {@code method} argument passed is null. */ public static QualifiedName fromAccessor( AccessibleObject method ) { NullArgumentException.validateNotNull( "method", method ); return fromClass( ( (Member) method ).getDeclaringClass(), ( (Member) method ).getName() ); }
public Triple addTripleManyAssociation( final ManyAssociationFunction<?> manyAssociationReference, final boolean optional ) { AssociationFunction<?> traversedAssociation = manyAssociationReference.traversedAssociation(); String subject = "?entity"; if( traversedAssociation != null ) { subject = addTripleAssociation( traversedAssociation, false ).value; } QualifiedName qualifiedName = QualifiedName.fromAccessor( manyAssociationReference.accessor() ); String predicatePrefix = addNamespace( qualifiedName.toNamespace() ); String predicate = predicatePrefix + ":" + qualifiedName.name(); Triple collectionTriple = addTriple( subject, predicate, optional ); String liSubject = collectionTriple.value; return addTriple( liSubject, "rdf:li", false ); }
if( IDENTITY_STATE_NAME.equals( ePropDesc.qualifiedName() ) ) = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) ) = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_COLLECTION_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) ) = vStateDesc.findPropertyModelByName( eAssocDesc.qualifiedName().name() ); if( STRING_MAP_TYPE_SPEC.satisfiedBy( vPropDesc.valueType() ) )
@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 ); } }
public Triple addTriple( final PropertyFunction<?> propertyFunction, boolean optional ) { String subject = "?entity"; if( propertyFunction.traversedAssociation() != null ) { subject = addTripleAssociation( propertyFunction.traversedAssociation(), false ).value; } else if( propertyFunction.traversedProperty() != null ) { subject = addTriple( propertyFunction.traversedProperty(), false ).value; } QualifiedName qualifiedName = QualifiedName.fromAccessor( propertyFunction.accessor() ); String prefix = addNamespace( qualifiedName.toNamespace() ); return addTriple( subject, prefix + ":" + qualifiedName.name(), optional ); }
/** * Creates a Qualified name from a type as string and a name qualifier. * * @param type The type name as a a string, which must be properly formatted. No checks for correctly formatted * type name is performed. * @param name The qualifier name which will be appended to the base name derived from the {@code type} argument. * * @return A QualifiedName instance representing the {@code type} and {@code name} arguments. * * @throws NullArgumentException if any of the two arguments are {@code null} or either string is empty. */ public static QualifiedName fromName( String type, String name ) { return new QualifiedName( TypeName.nameOf( type ), name ); }
@Override public EntityReference map( AssociationDescriptor associationDescriptor ) { Parameter param = queryAsForm.getFirst( associationDescriptor.qualifiedName().name() ); if( param == null ) { param = entityAsForm.getFirst( associationDescriptor.qualifiedName().name() ); } if( param != null ) { return EntityReference.parseEntityReference( param.getValue() ); } else { return null; } } },
/** * Creates a QualifiedName from the external string format of QualifiedName. * <p> * This factory method is the reverse of {@link QualifiedName#toString() } method, and creates a new QualifiedName * instance from the string representation of the QualifiedName. * </p> * * @param fullQualifiedName The QualifiedName external string representation to be converted back into a QualifiedName * instance. * * @return The QualifiedName instance represented by the {@code qualifiedName} argument. * * @throws IllegalArgumentException If the {@code qualifiedName} argument has wrong format. */ public static QualifiedName fromFQN( String fullQualifiedName ) { NullArgumentException.validateNotEmpty( "qualifiedName", fullQualifiedName ); int idx = fullQualifiedName.lastIndexOf( ":" ); if( idx == -1 ) { throw new IllegalArgumentException( "Name '" + fullQualifiedName + "' is not a qualified name" ); } final String type = fullQualifiedName.substring( 0, idx ); final String name = fullQualifiedName.substring( idx + 1 ); return new QualifiedName( TypeName.nameOf( type ), name ); }
@Override public Object map( PropertyDescriptor propertyDescriptor ) { Parameter param = queryAsForm.getFirst( propertyDescriptor.qualifiedName().name() ); if( param == null ) { param = entityAsForm.getFirst( propertyDescriptor.qualifiedName().name() ); } if( param != null ) { String value = param.getValue(); if( value != null ) { try { return valueDeserializer.deserialize( propertyDescriptor.valueType(), value ); } catch( ValueSerializationException e ) { throw new IllegalArgumentException( "Query parameter has invalid JSON format", e ); } } } return null; } },
@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 Object map( PropertyDescriptor ePropDesc ) { String propName = ePropDesc.qualifiedName().name(); try { PropertyDescriptor vPropDesc = vStateDesc.findPropertyModelByName( propName ); return vState.propertyFor( vPropDesc.accessor() ).get(); } catch( IllegalArgumentException propNotFoundOnValue ) { // Property not found on Value return null; } } };
@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; } },
@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() ); } },