utils/eclipselink.utils.workbench.test/mappingsplugin/source/org/eclipse/persistence/tools/workbench/test/models/employee/Employee.java

/*******************************************************************************
 * Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.tools.workbench.test.models.employee;

import java.io.Serializable;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.sql.Time;
import java.util.Map;
import java.util.Vector;

import org.eclipse.persistence.indirection.ValueHolder;
import org.eclipse.persistence.indirection.ValueHolderInterface;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.sessions.Record;
import org.eclipse.persistence.sessions.Session;

/** 
 * <p><b>Purpose</b>: Represent a employee of an organization.
 * <p><b>Description</b>: An Employee is a root object in the Employee Demo.
 * It maintains relationships to all of the other objects in the system.
 * The employee shows usage of 1-1, 1-m, m-m, aggregate and transformation mappings.
 * The employee also shows usage of value holder to implement indirection for its relationships
 * (note, it is strongly suggested to always use value holders for relationships).
 */

public class Employee implements EmployeeInterface, Serializable {
	/** Primary key, maped as a direct-to-field, BigDecimal -> NUMBER, that makes use of sequence numbers to generate the id. */
	public BigDecimal id;
	/** Direct-to-field mapping, String -> VARCHAR. */
	public String firstName;
	/** Direct-to-field mapping, String -> VARCHAR. */
	public String lastName;
	/** Object-type mapping, maps "Male" -> "M", "Female" -> "F". */
	public String gender;
	/** Aggregate-object mapping, stores the object in the employee's table. */
	public EmploymentPeriod period;
	/** One-to-one mapping, employee references its address through a foreign key. */
	public ValueHolderInterface address;
	/** One-to-one mapping (same class relationship), employee references its manager through a foreign key. */
	public ValueHolderInterface manager;
	/** One-to-many mapping (same class relationship), inverse relationship to manager, uses manager foreign key in the target. */
	public ValueHolderInterface managedEmployees;
	/** One-to-many mapping, employee references its collection of phone numbers using a foreign key in the phone's table. */
	public ValueHolderInterface phoneNumbers;
	/** Many-to-many mapping, employee references its projects through an intermediate join table. */
	public ValueHolderInterface projects;
	/** Direct-collection mapping, employee stores its collection of plain Strings in an intermediate table. */
	public ValueHolderInterface responsibilitiesList;
	/** Transformation mapping, a two(2) element array holding the employee's normal working hours (START_TIME & END_TIME),
		this is stored into two different fields in the employee table. */
	public Time[] normalHours;
	/** Direct-to-field mapping, int -> NUMBER, salary of the employee in dollars. */
	public int salary;
	
	/** 
	 * key is a String email address type (work, personal, spam, etc)
	 * value is a String email address
	 */
	public Map emailAddressMap;
	
/**
 *	For fields that make use of indirection the constructor should build the value holders.
 */

public Employee()
{
	this.firstName = "";
	this.lastName = "";
	this.address = new ValueHolder();
	this.manager = new ValueHolder();
	this.managedEmployees = new ValueHolder(new Vector());
	this.projects = new ValueHolder(new Vector());
	this.responsibilitiesList = new ValueHolder(new Vector());
	this.phoneNumbers = new ValueHolder(new Vector());
	this.normalHours = new Time[] {new Time(9, 0, 0), new Time(17,0,0)};
}
/**
 * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it.
 */

public void addManagedEmployee(EmployeeInterface employee)
{
  	getManagedEmployees().addElement(employee);
  	employee.setManager(this);
}
/**
 * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it.
 */

public void addPhoneNumber(PhoneNumber phoneNumber)
{
	getPhoneNumbers().addElement(phoneNumber);
	phoneNumber.setOwner(this);
}
public void addProject(ProjectInterface project)
{
  	getProjects().addElement(project);
}
public void addResponsibility(String responsibility)
{
  	getResponsibilitiesList().addElement(responsibility);
}
/**
 *	Builds the normalHours Vector. 
 *	IMPORTANT: 	This method builds the value but does not set it. 
 *						The mapping will set it using method or direct access 
 *						as defined in the descriptor.
 */
public Time[] buildNormalHours(Record row, Session session)
{
	Time[] hours = new Time[2];

	/** This conversion allows for the database type not to match, i.e. may be a Timestamp or String. */
	hours[0] = (Time) ((AbstractSession)session).getPlatform().convertObject(row.get("START_TIME"), java.sql.Time.class);
	hours[1] = (Time) ((AbstractSession)session).getPlatform().convertObject(row.get("END_TIME"), java.sql.Time.class);	
	return hours;
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public Address getAddress()
{
	return (Address) address.getValue();
}
/**
 *	Return the last element of the Transformation mapped normalHours.
 */

public Time getEndTime()
{
	return getNormalHours()[1];
}
public String getFirstName()
{
	return firstName;
}
public String getGender()
{
	return gender;
}
/**
 * Return the persistent identifier of the receiver.
 */

public BigDecimal getId()
{
	return id;
}
public String getLastName() {
	return lastName;
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public Vector getManagedEmployees()
{
	return (Vector) managedEmployees.getValue();
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public EmployeeInterface getManager()
{
	return (EmployeeInterface) manager.getValue();
}
public Time[] getNormalHours()
{
	return normalHours;
}
public EmploymentPeriod getPeriod()
{
	return period;
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public Vector getPhoneNumbers()
{
	return (Vector) phoneNumbers.getValue();
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public Vector getProjects()
{
	return (Vector) projects.getValue();
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public Vector getResponsibilitiesList()
{
	return (Vector) responsibilitiesList.getValue();
}
public int getSalary()
{
	return salary;
}
/**
 *	Return the first element of the Transformation mapped normalHours.
 */

public java.sql.Time getStartTime()
{
	return getNormalHours()[0];
}
/**
 * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it.
 */

public void removeManagedEmployee(EmployeeInterface employee)
{
  	getManagedEmployees().removeElement(employee);
	employee.setManager(null);
}
/**
 * Remove the phone number.
 * The phone number's owner must not be set to null as it is part of it primary key,
 * and you can never change the primary key of an existing object.
 * Only in independent relationships should you null out the back reference.
 */

public void removePhoneNumber(PhoneNumber phoneNumber)
{
	getPhoneNumbers().removeElement(phoneNumber);
}
public void removeProject(ProjectInterface project)
{
  	getProjects().removeElement(project);
}
public void removeResponsibility(String responsibility)
{
  	getResponsibilitiesList().removeElement(responsibility);
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setAddress(Address address)
{
	this.address.setValue(address);
}
/**
 *	Set the last element of the Transformation mapped normalHours.
 */

public void setEndTime(Time endTime)
{
	getNormalHours()[1] = endTime;
}
public void setFemale()
{
	setGender("Female");
}
public void setFirstName(String firstName)
{
	this.firstName = firstName;
}
public void setGender(String gender)
{
	this.gender = gender;
}
/**
 * Set the persistent identifier of the receiver.
 * Note this should never be changed.
 * Consider making the primary key set methods protected or not having them.
 * In this demo the setId is required for testing purposes.
 */

public void setId(BigDecimal id)
{
	this.id = id;
}
public void setLastName(String lastName)
{
	this.lastName = lastName;
}
public void setMale()
{
	setGender("Male");
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setManagedEmployees(Vector managedEmployees)
{
	this.managedEmployees.setValue(managedEmployees);
}
/**
 * For bi-directional relationships, it is important to maintain both sides of the relationship when changing it.
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setManager(EmployeeInterface manager)
{
	this.manager.setValue(manager);
}
public void setNormalHours(Time[] normalHours)
{
	this.normalHours = normalHours;
}
public void setPeriod(EmploymentPeriod period)
{
	this.period = period;
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setPhoneNumbers(Vector phoneNumbers)
{
	this.phoneNumbers.setValue(phoneNumbers);
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setProjects(Vector projects)
{
	this.projects.setValue(projects);
}
/**
 * Notice that the usage of value holders does not effect the public interface or usage of the class.
 * The get/set methods must however be changed to wrap/unwrap the value holder.
 */

public void setResponsibilitiesList(Vector responsibilitiesList)
{
	this.responsibilitiesList.setValue(responsibilitiesList);
}
public void setSalary(int salary)
{
	this.salary = salary;
}
/**
 *	Set the first element of the Transformation mapped normalHours.
 */

public void setStartTime(Time startTime)
{
	getNormalHours()[0] = startTime;
}
/**
 * Print the first & last name
 */

@Override
public String toString()
{
	StringWriter writer = new StringWriter();
	
	writer.write("Employee: ");	
	writer.write(getFirstName());
	writer.write(" ");
	writer.write(getLastName());
	return writer.toString();
}
}