How to use org.objectweb.celtix.configuration.impl

private void deserialize(Document document) {
  deseralizePackageName(document);
  deserializeTypes(document);
  deserializeElements(document);
}

public static DefaultConfigurationProviderFactory getInstance() {
  if (null == theInstance) {
    theInstance = new DefaultConfigurationProviderFactory();
  }
  return theInstance;
}

public boolean setString(String name, String value) {
  return setObject(name, (String)value);
}

  private void unmarshalDefaultValue(ConfigurationItemMetadataImpl item, Element data) {
    TypeSchema ts = new TypeSchemaHelper(forceDefaults).get(data.getNamespaceURI());
    Object obj = ts.unmarshalDefaultValue(item, data, doValidate);
    if (null != obj) {
      item.setDefaultValue(obj);
    }
  }
}

public AbstractConfigurationImpl(ConfigurationMetadata m, String instanceId, Configuration parent) {
  model = m;
  id = instanceId;
  configurator = new ConfiguratorImpl(this, parent instanceof AbstractConfigurationImpl
                    ? (AbstractConfigurationImpl)parent
                    : null);
  providers = new Vector<ConfigurationProvider>();
  // temporary:
  //providers.add(new InMemoryProvider());
  DefaultConfigurationProviderFactory factory = DefaultConfigurationProviderFactory.getInstance();
  ConfigurationProvider defaultProvider = factory.createDefaultProvider(this);
  if (null != defaultProvider) {
    providers.add(defaultProvider);
  }
}

public Object unmarshal(QName type, Element data) throws JAXBException {
  return unmarshal(type, data, true);
}

public static QName elementValueToQName(Document document, Element element) {
  return stringToQName(document, element, getElementValue(element));
}

public Object unmarshalDefaultValue(ConfigurationItemMetadata item, Element data) {
  return unmarshalDefaultValue(item, data, false);
}

private Validator getMetadataValidator() {
  if (null == metadataValidator) {
    Schema schema = getMetadataSchema();
    // assert null != schema;
    metadataValidator = schema.newValidator();
    if (null == validatorErrorHandler) {
      validatorErrorHandler = new ValidatorErrorHandler();
    }
    metadataValidator.setErrorHandler(validatorErrorHandler);
    // assert null != metadataValidator;
  }
  return metadataValidator;
}

public Validator getValidator() {
  if (null == validator) {
    Schema s = getSchema();
    validator = s.newValidator();
    validator.setErrorHandler(new TypeSchemaErrorHandler());
  }
  return validator;
}

public Configuration buildConfiguration(String namespaceUri, String id) {
  return buildConfiguration(namespaceUri, id, null);
}

public ConfigurationMetadataBuilder(boolean fd) {
  model = new ConfigurationMetadataImpl();
  forceDefaults = fd;
}

public ConfigurationMetadata build(InputSource is) throws IOException {
  parseXML(is);
  return model;
}

public <T> T getObject(Class<T> cls, String name) {
  Object obj = getObject(name);
  return cls.cast(obj);
}

public static QName elementAttributeToQName(Document document, Element element, String attrName) {
  return stringToQName(document, element, element.getAttribute(attrName));
}

public TypeSchema get(String namespaceURI, String base, String location) {
  TypeSchema ts = map.get(namespaceURI);
  if (null == ts) {
    ts = new TypeSchema(namespaceURI, base, location, forceDefaults);
    map.put(namespaceURI, ts);
  }
  return ts;
}

public boolean setShort(String name, short value) {
  return setObject(name, new Short(value));
}

public boolean setInt(String name, int value) {
  return setObject(name, new Integer(value));
}

public boolean setBoolean(String name, boolean value) {
  return setObject(name, Boolean.valueOf(value));
}

public boolean setLong(String name, long value) {
  return setObject(name, new Long(value));
}