• Home
• org.projectodd.shrinkwrap.descriptors
• shrinkwrap-descriptors-api-javaee
• 2.0.0-alpha-7a
• source code
• Attributes.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jboss.shrinkwrap.descriptor.api.orm10.Attributes Maven / Gradle / Ivy

package org.jboss.shrinkwrap.descriptor.api.orm10; 

import java.util.ArrayList;
import java.util.List;
import org.jboss.shrinkwrap.descriptor.api.Child;
import org.jboss.shrinkwrap.descriptor.api.orm10.Id;
import org.jboss.shrinkwrap.descriptor.api.orm10.EmbeddedId;
import org.jboss.shrinkwrap.descriptor.api.orm10.Basic;
import org.jboss.shrinkwrap.descriptor.api.orm10.Version;
import org.jboss.shrinkwrap.descriptor.api.orm10.ManyToOne;
import org.jboss.shrinkwrap.descriptor.api.orm10.OneToMany;
import org.jboss.shrinkwrap.descriptor.api.orm10.OneToOne;
import org.jboss.shrinkwrap.descriptor.api.orm10.ManyToMany;
import org.jboss.shrinkwrap.descriptor.api.orm10.Embedded;
import org.jboss.shrinkwrap.descriptor.api.orm10.Transient;
import org.jboss.shrinkwrap.descriptor.api.orm.*;
import org.jboss.shrinkwrap.descriptor.api.orm.OrmAttributesCommType;

import org.jboss.shrinkwrap.descriptor.api.orm10.Id;
import org.jboss.shrinkwrap.descriptor.api.orm10.EmbeddedId;
import org.jboss.shrinkwrap.descriptor.api.orm10.Basic;
import org.jboss.shrinkwrap.descriptor.api.orm10.Version;
import org.jboss.shrinkwrap.descriptor.api.orm10.ManyToOne;
import org.jboss.shrinkwrap.descriptor.api.orm10.OneToMany;
import org.jboss.shrinkwrap.descriptor.api.orm10.OneToOne;
import org.jboss.shrinkwrap.descriptor.api.orm10.ManyToMany;
import org.jboss.shrinkwrap.descriptor.api.orm10.Embedded;
import org.jboss.shrinkwrap.descriptor.api.orm10.Transient;/**
 * This interface defines the contract for the  attributes  xsd type 
 * @author Ralf Battenfeld
 * @author Andrew Lee Rubinger
 * @author George Gastaldi
 */
public interface Attributes extends Child, 
    OrmAttributesCommType,
    Id>,
    EmbeddedId>,
    Basic>,
    Version>,
    ManyToOne>,
    OneToMany>,
    OneToOne>,
    ManyToMany>,
    Embedded>,
    Transient>> { 

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:id ElementType : id
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new id element will be created and returned.
    * Otherwise, the first existing id element will be returned.
    * @return the instance defined for the element id 
    */
   public Id> getOrCreateId();

   /**
    * Creates a new id element 
    * @return the new created instance of Id> 
    */
   public Id> createId();

   /**
    * Returns all id elements
    * @return list of id 
    */
   public List>> getAllId();

   /**
    * Removes all id elements 
    * @return the current instance of Id> 
    */
   public Attributes removeAllId();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:embedded-id ElementType : embedded-id
   // MaxOccurs: -  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new embedded-id element with the given value will be created.
    * Otherwise, the existing embedded-id element will be returned.
    * @return  a new or existing instance of EmbeddedId> 
    */
   public EmbeddedId> getOrCreateEmbeddedId();

   /**
    * Removes the embedded-id element 
    * @return the current instance of Attributes 
    */
   public Attributes removeEmbeddedId();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:basic ElementType : basic
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new basic element will be created and returned.
    * Otherwise, the first existing basic element will be returned.
    * @return the instance defined for the element basic 
    */
   public Basic> getOrCreateBasic();

   /**
    * Creates a new basic element 
    * @return the new created instance of Basic> 
    */
   public Basic> createBasic();

   /**
    * Returns all basic elements
    * @return list of basic 
    */
   public List>> getAllBasic();

   /**
    * Removes all basic elements 
    * @return the current instance of Basic> 
    */
   public Attributes removeAllBasic();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:version ElementType : version
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new version element will be created and returned.
    * Otherwise, the first existing version element will be returned.
    * @return the instance defined for the element version 
    */
   public Version> getOrCreateVersion();

   /**
    * Creates a new version element 
    * @return the new created instance of Version> 
    */
   public Version> createVersion();

   /**
    * Returns all version elements
    * @return list of version 
    */
   public List>> getAllVersion();

   /**
    * Removes all version elements 
    * @return the current instance of Version> 
    */
   public Attributes removeAllVersion();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:many-to-one ElementType : many-to-one
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new many-to-one element will be created and returned.
    * Otherwise, the first existing many-to-one element will be returned.
    * @return the instance defined for the element many-to-one 
    */
   public ManyToOne> getOrCreateManyToOne();

   /**
    * Creates a new many-to-one element 
    * @return the new created instance of ManyToOne> 
    */
   public ManyToOne> createManyToOne();

   /**
    * Returns all many-to-one elements
    * @return list of many-to-one 
    */
   public List>> getAllManyToOne();

   /**
    * Removes all many-to-one elements 
    * @return the current instance of ManyToOne> 
    */
   public Attributes removeAllManyToOne();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:one-to-many ElementType : one-to-many
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new one-to-many element will be created and returned.
    * Otherwise, the first existing one-to-many element will be returned.
    * @return the instance defined for the element one-to-many 
    */
   public OneToMany> getOrCreateOneToMany();

   /**
    * Creates a new one-to-many element 
    * @return the new created instance of OneToMany> 
    */
   public OneToMany> createOneToMany();

   /**
    * Returns all one-to-many elements
    * @return list of one-to-many 
    */
   public List>> getAllOneToMany();

   /**
    * Removes all one-to-many elements 
    * @return the current instance of OneToMany> 
    */
   public Attributes removeAllOneToMany();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:one-to-one ElementType : one-to-one
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new one-to-one element will be created and returned.
    * Otherwise, the first existing one-to-one element will be returned.
    * @return the instance defined for the element one-to-one 
    */
   public OneToOne> getOrCreateOneToOne();

   /**
    * Creates a new one-to-one element 
    * @return the new created instance of OneToOne> 
    */
   public OneToOne> createOneToOne();

   /**
    * Returns all one-to-one elements
    * @return list of one-to-one 
    */
   public List>> getAllOneToOne();

   /**
    * Removes all one-to-one elements 
    * @return the current instance of OneToOne> 
    */
   public Attributes removeAllOneToOne();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:many-to-many ElementType : many-to-many
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new many-to-many element will be created and returned.
    * Otherwise, the first existing many-to-many element will be returned.
    * @return the instance defined for the element many-to-many 
    */
   public ManyToMany> getOrCreateManyToMany();

   /**
    * Creates a new many-to-many element 
    * @return the new created instance of ManyToMany> 
    */
   public ManyToMany> createManyToMany();

   /**
    * Returns all many-to-many elements
    * @return list of many-to-many 
    */
   public List>> getAllManyToMany();

   /**
    * Removes all many-to-many elements 
    * @return the current instance of ManyToMany> 
    */
   public Attributes removeAllManyToMany();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:embedded ElementType : embedded
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new embedded element will be created and returned.
    * Otherwise, the first existing embedded element will be returned.
    * @return the instance defined for the element embedded 
    */
   public Embedded> getOrCreateEmbedded();

   /**
    * Creates a new embedded element 
    * @return the new created instance of Embedded> 
    */
   public Embedded> createEmbedded();

   /**
    * Returns all embedded elements
    * @return list of embedded 
    */
   public List>> getAllEmbedded();

   /**
    * Removes all embedded elements 
    * @return the current instance of Embedded> 
    */
   public Attributes removeAllEmbedded();

 
   // --------------------------------------------------------------------------------------------------------||
   // ClassName: Attributes ElementName: orm:transient ElementType : transient
   // MaxOccurs: -unbounded  isGeneric: true   isAttribute: false isEnum: false isDataType: false
   // --------------------------------------------------------------------------------------------------------||

   /**
    * If not already created, a new transient element will be created and returned.
    * Otherwise, the first existing transient element will be returned.
    * @return the instance defined for the element transient 
    */
   public Transient> getOrCreateTransient();

   /**
    * Creates a new transient element 
    * @return the new created instance of Transient> 
    */
   public Transient> createTransient();

   /**
    * Returns all transient elements
    * @return list of transient 
    */
   public List>> getAllTransient();

   /**
    * Removes all transient elements 
    * @return the current instance of Transient> 
    */
   public Attributes removeAllTransient();
}