public SchemaIdentityConstraintImpl(SchemaContainer c) 
{
       
        _container = c;
}

 public  void buildPaths() throws XPath.XPathCompileException 
{
        // TODO: Need the namespace map - requires store support
        _selectorPath = XPath.compileXPath(_selector, _nsMap);
        _fieldPaths = new XPath[_fields.length];
        for (int i = 0 ; i <  _fieldPaths.length ; i++)
            _fieldPaths[i] = XPath.compileXPath(_fields[i], _nsMap);
}

 public SchemaAnnotation getAnnotation() 
{
        return _annotation;
}

 public String getChameleonNamespace() 
{
        return _chameleon ? _parseTNS : null;
}

 public SchemaComponent.Ref getComponentRef() 
{
 return getRef();
}

 public int getComponentType() 
{
        return IDENTITY_CONSTRAINT;
}

 public int getConstraintCategory() 
{
        return _type;
}

 SchemaContainer getContainer() 
{
        return _container;
}

 public Object getFieldPath(int index) 
{
        XPath[] p = _fieldPaths;
        if (p == null) {
            try {
                buildPaths();
                p = _fieldPaths;
            }
            catch (XPath.XPathCompileException e) {
                assert false: "Failed to compile xpath. Should be caught by compiler " + e;
                return null;
            }
        }
        return p[index];
}

 public String[] getFields() 
{
        String[] fields = new String[_fields.length];
        System.arraycopy(_fields, 0, fields, 0, fields.length);
        return fields;
}

 public Map getNSMap() 
{
        return Collections.unmodifiableMap(_nsMap);
}

 public QName getName() 
{
        return _name;
}

 public XmlObject getParseObject() 
{
        return _parse;
}

 public SchemaIdentityConstraint.Ref getRef() 
{
      
         return _selfref;
}

 public SchemaIdentityConstraint getReferencedKey() 
{
        return _key.get();
}

 public String getSelector() 
{
        return _selector;
}

 public Object getSelectorPath() 
{
        XPath p = _selectorPath;
        if (p == null) {
            try {
                buildPaths();
                p = _selectorPath;
            }
            catch (XPath.XPathCompileException e) {
                assert false: "Failed to compile xpath. Should be caught by compiler " + e;
                return null;
            }
        }
        return p;
}

 public String getSourceName() 
{
 return _filename;
}

 public String getTargetNamespace() 
{
        return _parseTNS;
}

 public SchemaTypeSystem getTypeSystem() 
{
        return _container.getTypeSystem();
}

 public Object getUserData() 
{
   return _userData;
}

 public boolean isResolved() 
{
        return getConstraintCategory() != CC_KEYREF || _key != null;
}

Only applicable to keyrefs. Other types are implicitly resolved.

 public  void setAnnotation(SchemaAnnotation ann) 
{
        _annotation = ann;
}

 public  void setConstraintCategory(int type) 
{
        assert type  >= CC_KEY && type < = CC_UNIQUE;
        _type = type;
}

 public  void setFields(String[] fields) 
{
        assert fields != null && fields.length  > 0;
        _fields = fields;
}

 public  void setFilename(String filename) 
{
 _filename = filename;
}

 public  void setNSMap(Map nsMap) 
{
        _nsMap = nsMap;
}

 public  void setName(QName name) 
{
        assert name != null;
        _name = name;
}

 public  void setParseContext(XmlObject o,
    String targetNamespace,
    boolean chameleon) 
{
        _parse = o;
        _parseTNS = targetNamespace;
        _chameleon = chameleon;
}

 public  void setReferencedKey(SchemaIdentityConstraint.Ref key) 
{
        _key = key;
}

 public  void setSelector(String selector) 
{
        assert selector != null;
        _selector = selector;
}

 public  void setUserData(Object data) 
{
   _userData = data;
}