Examples of MetadataManager

com.facebook.presto.metadata.MetadataManager
edu.uga.galileo.voci.model.MetadataManager
Manages all metadata-related information in the model, standing between the servlets and the DAOs. @author Mark Durant @version 1.0
org.apache.lenya.cms.metadata.MetaDataManager
Manager for meta data of a Lenya resource/document @version $Id: MetaDataManager.java 179568 2005-06-02 09:27:26Z jwkaltz $
org.apache.ojb.broker.metadata.MetadataManager
the manager to use per thread mode mm.setEnablePerThreadChanges(true); ... This could be done e.g. at start up.
Now it's possible to use dedicated DescriptorRepository instances per thread:
```
 // e.g we get a coppy of the global repository DescriptorRepository dr = mm.copyOfGlobalRepository(); // now we can manipulate the persistent object metadata of the copy ...... // set the changed repository for this thread mm.setDescriptor(dr); // now let this thread lookup a PersistenceBroker instance // with the modified metadata // all other threads use the global metadata PersistenceBroker broker = Persis...... 
```
Note: Change metadata before lookup the {@link org.apache.ojb.broker.PersistenceBroker}instance for current thread, because the metadata was bound to the PB at lookup.

How to use different metadata profiles
MetadataManager was shipped with a simple mechanism to add, remove and load different persistent objects metadata profiles (different {@link org.apache.ojb.broker.metadata.DescriptorRepository}instances) in a per thread manner. Use
- {@link #addProfile addProfile} add different persistent object metadata profiles
- {@link #removeProfile removeProfile} remove a persistent object metadata profiles
- {@link #loadProfile loadProfile} load a profile for the current thread
Note: method {@link #loadProfile loadProfile} only works ifthe per thread mode is enabled.
@author Armin Waibel @version $Id: MetadataManager.java,v 1.19.2.7 2005/12/21 22:26:10 tomdz Exp $
org.datanucleus.metadata.MetaDataManager
Manager of metadata information in DataNucleus having scope of an ObjectManagerFactory. Each PMF/EMF will effectively have a single MetaDataManager handling all XML/Annotations metadata.
Metadata can be loaded into the MetaDataManager in two ways
- Load when required. When the persistence process needs a class it will ask for metadata, and we can go and find its metadata from XML/annotations.
- Load explicitly via API calls. This happens when handling persistence for a persistence-unit for example since we know what classes/mapping is involved. It is also the case with the enhancer where we know what classes to enhance so we load the metadata first
Acts as a registry of metadata so that metadata files don't need to be parsed multiple times. MetaData is stored as a FileMetaData, which contains PackageMetaData, which contains ClassMetaData, and so on. This maps exactly to the users model of their metadata. The users access point is getMetaDataForClass() which will check the known classes without metadata, then check the existing registered metdata, then check the valid locations for metdata files. This way, the metadata is managed from this single point.

Maintains a list of all classes that have been checked for MetaData and don't have any available. This avoids the needs to look up MetaData multiple times finding the same result. Currently this list is for all ClassMetaData objects keyed by the class name.

Users can register interest in knowing when metadata for classes are loaded by registering a listener using the addListener method. This will then notify the listener when metadata for any class is initialised. This provides the opportunity to reject the metadata where particular features are not supported. For example a StoreManager could register a listener where it doesn't support datastore identity and throw an InvalidMetaDataException. This would then filter back out to the user for the operation they invoked
org.jpox.metadata.MetaDataManager
Manager of MetaData information in JPOX having scope of an ObjectManagerFactory. Each PMF/EMF will effectively have a single MetaDataManager handling all XML/Annotations MetaData.
A MetaDataManager can be "initialised" to start with particular MetaData. This is typically performed when the operation has a "persistence-unit", which defines the classes/jars/mapping-files to use. Alternatively, it can be initialised using a set of classes and mapping-files (for use by SchemaTool and the Enhancer when specifying the files as input).
Acts as a registry of metadata so that metadata files don't need to be parsed multiple times. MetaData is stored as a FileMetaData, which contains PackageMetaData, which contains ClassMetaData, and so on. This maps exactly to the users model of their metadata. The users access point is getMetaDataForClass() which will check the known classes without metadata, then check the existing registered metdata, then check the valid locations for metdata files. This way, the metadata is managed from this single point.

Maintains a list of all classes that have been checked for MetaData and don't have any available. This avoids the needs to look up MetaData multiple times finding the same result. Currently this list is for all ClassMetaData objects keyed by the class name.
TODO Update MetaDataManager to be able to share ClassMetaData with other MetaDataManager so we need a central (singleton/static) registry that allows such communication. @version $Revision: 1.170 $
org.openquark.cal.metadata.MetadataManager
This class implements the metadata manager responsible for saving and loading CALFeatureMetadata objects to a MetadataStore using XML files. @author Frank Worsley
org.springframework.security.saml.metadata.MetadataManager
Class offers extra services on top of the underlying chaining MetadataProviders. Manager keeps track of all available identity and service providers configured inside the chained metadata providers. Exactly one service provider can be determined as hosted.
The class is synchronized using in internal ReentrantReadWriteLock.
All metadata providers are kept in two groups - available providers - which contain all the ones users have registered, and active providers - all those which passed validation. List of active providers is updated during each refresh. @author Vladimir Schaefer
thredds.inventory.bdb.MetadataManager
MetadataManager using Berkeley DB Java Edition. Single environment, with multiple databases. All threads share one environment; multiple processes can only have one writer at a time. Each collection is a "database". Each database has a set of key/value pairs. default root dir is ${user.home}/.unidata/bdb default TDS uses {tomcat_home}/content/thredds/cache/collection @author caron @since Aug 20, 2008

Examples of org.datanucleus.metadata.MetaDataManager

  }


  public void testIgnorableMapping_ErrorConfig() {
    setIgnorableMetaDataBehavior(MetaDataValidator.IgnorableMetaDataBehavior.ERROR.name());
    NucleusContext nucContext = ((JDOPersistenceManagerFactory)pmf).getNucleusContext();
    MetaDataManager mdm = nucContext.getMetaDataManager();
    AbstractClassMetaData acmd =
        mdm.getMetaDataForClass(Flight.class, nucContext.getClassLoaderResolver(getClass().getClassLoader()));
    MetaDataValidator mdv = new MetaDataValidator((DatastoreManager) nucContext.getStoreManager(), mdm, null) {
      @Override
      void warn(String msg) {
        fail("shouldn't have been called");
      }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

        // PERSISTENT INTERFACE : allow for the value (impl) not be directly assignable from the superclass impl
        // e.g If we have interface "Base" with impl "BaseImpl", and sub-interface "Sub1" with impl "Sub1Impl"
        // So if the mapping is of type BaseImpl and the value is Sub1Impl then they don't come up as "assignable"
        // but they are
        Class mappingJavaType = null;
        MetaDataManager mmgr = storeMgr.getNucleusContext().getMetaDataManager();
        boolean isPersistentInterface = mmgr.isPersistentInterface(getType());
        if (isPersistentInterface)
        {
            // Field is declared as a "persistent-interface" type so all impls of that type should match
            mappingJavaType = clr.classForName(getType());
        }
        else if (mmd != null && mmd.getFieldTypes() != null && mmd.getFieldTypes().length == 1)
        {
            isPersistentInterface = mmgr.isPersistentInterface(mmd.getFieldTypes()[0]);
            if (isPersistentInterface)
            {
                // Field is declared as interface and accepts "persistent-interface" value, so all impls should match
                mappingJavaType = clr.classForName(mmd.getFieldTypes()[0]);
            }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

    }
  }


  protected String kindForClass(Class<?> clazz) {
    ExecutionContext om = getExecutionContext();
    MetaDataManager mdm = om.getMetaDataManager();
    return EntityUtils.determineKind(
        mdm.getMetaDataForClass(clazz, om.getClassLoaderResolver()), om);
  }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

        new com.google.appengine.api.datastore.Query(kind)).countEntities();
  }


  protected String kindForClass(Class<?> clazz) {
    ExecutionContext om = getExecutionContext();
    MetaDataManager mdm = om.getMetaDataManager();
    return EntityUtils.determineKind(
        mdm.getMetaDataForClass(clazz, om.getClassLoaderResolver()), om);
  }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

    return ds.prepare(new Query(kind)).countEntities();
  }


  protected String kindForClass(Class<?> clazz) {
    NucleusContext nucContext = ((JPAEntityManagerFactory)emf).getNucleusContext();
    MetaDataManager mdm = nucContext.getMetaDataManager();
    MappedStoreManager storeMgr = (MappedStoreManager) nucContext.getStoreManager();
    ClassLoaderResolver clr = nucContext.getClassLoaderResolver(getClass().getClassLoader());
    return EntityUtils.determineKind(
        mdm.getMetaDataForClass(
            clazz,
            nucContext.getClassLoaderResolver(getClass().getClassLoader())),
            storeMgr,
            clr);
  }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

    }
  }


  protected String kindForClass(Class<?> clazz) {
    NucleusContext nucContext = ((JPAEntityManagerFactory)emf).getNucleusContext();
    MetaDataManager mdm = nucContext.getMetaDataManager();
    MappedStoreManager storeMgr = (MappedStoreManager) nucContext.getStoreManager();
    ClassLoaderResolver clr = nucContext.getClassLoaderResolver(getClass().getClassLoader());
    return EntityUtils.determineKind(
        mdm.getMetaDataForClass(
            clazz,
            nucContext.getClassLoaderResolver(getClass().getClassLoader())),
            storeMgr,
            clr);
  }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

        this.emd = emd;
        this.typeName = typeName;
        this.objectType = (short) objectType;


        // Find the MetaData for the embedded PC class
        MetaDataManager mmgr = datastoreContainer.getStoreManager().getMetaDataManager();
        AbstractClassMetaData rootEmbCmd = mmgr.getMetaDataForClass(typeName, clr);
        if (rootEmbCmd == null)
        {
            // Not found so must be an interface
            if (fmd != null)
            {
                // Try using the fieldTypes on the field/property - we support it if only 1 implementation
                String[] fieldTypes = fmd.getFieldTypes();
                if (fieldTypes != null && fieldTypes.length == 1)
                {
                    rootEmbCmd = mmgr.getMetaDataForClass(fieldTypes[0], clr);
                }
                else if (fieldTypes != null && fieldTypes.length > 1)
                {
                    // TODO Cater for multiple implementations
                    throw new NucleusUserException("Field " + fmd.getFullFieldName() + 
                        " is a reference field that is embedded with multiple possible implementations. " +
                        "DataNucleus doesnt support embedded reference fields that have more than 1 implementation");
                }
            }


            if (rootEmbCmd == null)
            {
                // Try a persistent interface
                rootEmbCmd = mmgr.getMetaDataForInterface(clr.classForName(typeName), clr);
                if (rootEmbCmd == null && fmd.getFieldTypes() != null && fmd.getFieldTypes().length == 1)
                {
                    // No MetaData for the type so try "fieldType" specified on the field
                    rootEmbCmd = mmgr.getMetaDataForInterface(clr.classForName(fmd.getFieldTypes()[0]), clr);
                }
            }
        }


        embCmd = rootEmbCmd;


        AbstractMemberMetaData[] embFmds;
        if (emd == null && rootEmbCmd.isEmbeddedOnly())
        {
            // No <embedded> block yet the class is defined as embedded-only so just use its own definition of fields
            embFmds = rootEmbCmd.getManagedMembers();
        }
        else
        {
            // <embedded> block so use those field definitions
            embFmds = emd.getMemberMetaData();
        }


        String[] subclasses = mmgr.getSubclassesForClass(rootEmbCmd.getFullClassName(), true);
        if (subclasses != null && subclasses.length > 0)
        {
            if (rootEmbCmd.hasDiscriminatorStrategy())
            {
                discrimMetaData = new DiscriminatorMetaData();

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager


    if (!allowSubclasses) {
      return false;
    }


    MetaDataManager mdm = ec.getMetaDataManager();
    // see if the key kind is a subclass of the requested kind
    String[] subclasses = mdm.getSubclassesForClass(cls.getName(), true);
    if (subclasses != null) {
      for (String subclass : subclasses) {
        AbstractClassMetaData subAcmd = mdm.getMetaDataForClass(subclass, ec.getClassLoaderResolver());
        if (key.getKind().equals(determineKind(subAcmd, ec))) {
          return true;
        }
      }
    }

View Full Code Here

Examples of org.datanucleus.metadata.MetaDataManager

      if (managesField(fmd.getFullFieldName())) {
        if (!fmd.getClassName(true).equals(curCmd.getFullClassName())) {
          throw new UnsupportedOperationException("Overrides not currently supported.");
        }
      } else {
        MetaDataManager mmgr = storeMgr.getMetaDataManager();


        // Manage the field if not already managed (may already exist if overriding a superclass field)
        JavaTypeMapping mapping = null;
        if (fmd.getPersistenceModifier() == FieldPersistenceModifier.PERSISTENT) {
          boolean isPrimary = true;
          if (fmd.getTable() != null && fmd.getJoinMetaData() == null) {
            // Field has a table specified and is not a 1-N with join table so is mapped to a secondary table
            isPrimary = false;
          }


          if (isPrimary) {
            // Add the field to this table
            mapping = dba.getMappingManager(storeMgr).getMapping(this, fmd, clr, FieldRole.ROLE_FIELD);
            addFieldMapping(mapping);
            embeddedFieldMappingsMap.put(fmd, fieldMappingsMap.get(fmd));
          } else {
            throw new UnsupportedOperationException("No support for secondary tables.");
          }
        } else if (fmd.getPersistenceModifier() != FieldPersistenceModifier.TRANSACTIONAL) {
          throw new NucleusException("Invalid persistence-modifier for field ").setFatal();
        }


        // Calculate if we need a FK adding due to a 1-N relationship TODO Remove this when no longer supporting old storageVersion
        // Note that we ignore any "join" setting since we don't use join tables
        boolean needsFKToContainerOwner = false;
        RelationType relationType = fmd.getRelationType(clr);
        if (relationType == RelationType.ONE_TO_MANY_BI) {
          /*AbstractMemberMetaData[] relatedMmds = fmd.getRelatedMemberMetaData(clr);
          if (fmd.getJoinMetaData() == null && relatedMmds[0].getJoinMetaData() == null) {*/
            needsFKToContainerOwner = true;
          /*}*/
        } else if (relationType == RelationType.ONE_TO_MANY_UNI) {
          /*if (fmd.getJoinMetaData() == null) {*/
            needsFKToContainerOwner = true;
          /*}*/
        } else if (relationType == RelationType.ONE_TO_ONE_BI) {
          if (fmd.getMappedBy() != null && MetaDataUtils.isOwnedRelation(fmd, storeMgr)) {
            // This element type has a many-to-one pointing back.
            // We assume that our pk is part of the pk of the element type.
            DatastoreTable dt = storeMgr.getDatastoreClass(fmd.getAbstractClassMetaData().getFullClassName(), clr);
            dt.runCallBacks();
            dt.markFieldAsParentKeyProvider(fmd.getName());
          }
        } else if (relationType == RelationType.MANY_TO_ONE_BI) {
        }


        if (needsFKToContainerOwner) {
          // 1-N uni/bidirectional using FK, so update the element side with a FK
          if ((fmd.getCollection() != null && !SCOUtils.collectionHasSerialisedElements(fmd)) ||
              (fmd.getArray() != null && !SCOUtils.arrayIsStoredInSingleColumn(fmd, mmgr))) {
            // 1-N ForeignKey collection/array, so add FK to element table
            AbstractClassMetaData elementCmd;
            if (fmd.hasCollection()) {
              // Collection
              elementCmd = mmgr.getMetaDataForClass(fmd.getCollection().getElementType(), clr);
            } else {
              // Array
              elementCmd = mmgr.getMetaDataForClass(fmd.getType().getComponentType(), clr);
            }
            if (elementCmd == null) {
              // Elements that are reference types or non-PC will come through here
            } else {
              AbstractClassMetaData[] elementCmds;
              // TODO : Cater for interface elements, and get the metadata for the implementation classes here
              if (elementCmd.getInheritanceMetaData().getStrategy() == InheritanceStrategy.SUBCLASS_TABLE) {
                elementCmds = storeMgr.getClassesManagingTableForClass(elementCmd, clr);
              } else {
                elementCmds = new ClassMetaData[1];
                elementCmds[0] = elementCmd;
              }


              // Run callbacks for each of the element classes.
              for (AbstractClassMetaData elementCmd1 : elementCmds) {
                callbacks.put(elementCmd1.getFullClassName(), new CallBack(fmd, cmd.getFullClassName()));
                DatastoreTable dt =
                    (DatastoreTable) storeMgr.getDatastoreClass(elementCmd1.getFullClassName(), clr);
                dt.runCallBacks();
                if (fmd.getMappedBy() != null && MetaDataUtils.isOwnedRelation(fmd, storeMgr)) {
                  // This element type has a many-to-one pointing back.
                  // We assume that our pk is part of the pk of the element type.
                  dt.markFieldAsParentKeyProvider(fmd.getMappedBy());
                }
              }
            }
          } else if (fmd.getMap() != null && !SCOUtils.mapHasSerialisedKeysAndValues(fmd)) {
            // 1-N ForeignKey map, so add FK to value table
            if (fmd.getKeyMetaData() != null && fmd.getKeyMetaData().getMappedBy() != null) {
              // Key is stored in the value table so add the FK to the value table
              AbstractClassMetaData valueCmd = mmgr.getMetaDataForClass(fmd.getMap().getValueType(), clr);
              if (valueCmd == null) {
                // Interface elements will come through here and java.lang.String and others as well
              }
            } else if (fmd.getValueMetaData() != null
                       && fmd.getValueMetaData().getMappedBy() != null) {
              // Value is stored in the key table so add the FK to the key table
              AbstractClassMetaData keyCmd = mmgr.getMetaDataForClass(fmd.getMap().getKeyType(), clr);
              if (keyCmd == null) {
                // Interface elements will come through here and java.lang.String and others as well
              } else {
              }
            }

View Full Code Here

Examples of org.jpox.metadata.MetaDataManager

        this.emd = emd;
        this.typeName = typeName;
        this.objectType = objectType;


        // Find the MetaData for the embedded PC class
        MetaDataManager mmgr = fmd.getAbstractClassMetaData().getMetaDataManager();
        AbstractClassMetaData pcCmd = mmgr.getMetaDataForClass(typeName, clr);
        if (pcCmd == null)
        {
            // Not found so must be an interface
            if (fmd != null)
            {
                // Try using the fieldTypes on the field/property - we support it if only 1 implementation
                String[] fieldTypes = fmd.getFieldTypes();
                if (fieldTypes != null && fieldTypes.length == 1)
                {
                    pcCmd = mmgr.getMetaDataForClass(fieldTypes[0], clr);
                }
                else if (fieldTypes != null && fieldTypes.length > 1)
                {
                    // TODO Cater for multiple implementations
                    throw new JPOXUserException("Field " + fmd.getFullFieldName() + " is a reference field that is embedded. " +
                        "JPOX doesnt support embedded reference fields that have more than 1 implementation");
                }
            }


            if (pcCmd == null)
            {
                // Try a persistent interface
                pcCmd = mmgr.getMetaDataForInterface(clr.classForName(typeName), clr);
                if (pcCmd == null && fmd.getFieldTypes() != null && fmd.getFieldTypes().length == 1)
                {
                    // No MetaData for the type so try "fieldType" specified on the field
                    pcCmd = mmgr.getMetaDataForInterface(clr.classForName(fmd.getFieldTypes()[0]), clr);
                }
            }
        }


        embCmd = pcCmd;

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.