/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package javaobject;

import org.apache.geode.DataSerializable;

import org.apache.geode.Delta;

import org.apache.geode.Instantiator;

import org.apache.geode.InvalidDeltaException;

import org.apache.geode.cache.util.ObjectSizer;

import org.apache.geode.cache.Declarable;

import org.apache.geode.internal.NanoTimer;

import org.apache.geode.*;

import java.io.*;

import java.util.*;

/**

* A {@link objects.FastAssetAccount} that implements the Delta interface.

*/

public class DeltaFastAssetAccount implements Declarable,Serializable,DataSerializable ,Delta, Cloneable {

public static boolean encodeTimestamp = false;

//protected boolean encodeTimestamp;

protected int acctId;

protected String customerName;

protected double netWorth = 0.0;

protected Map assets;

protected long timestamp;

protected static final boolean getBeforeUpdate = false;

static {

Instantiator.register(new Instantiator(DeltaFastAssetAccount.class, (byte) 41) {

public DataSerializable newInstance() {

return new DeltaFastAssetAccount();

}

});

}

public void init(Properties props) {

this.acctId = Integer.parseInt(props.getProperty("acctId"));

this.customerName = props.getProperty("customerName");

if(props.getProperty("netWorth") != null) {

this.netWorth = Double.parseDouble( props.getProperty("netWorth") );

}

}

public DeltaFastAssetAccount() {

}

public DeltaFastAssetAccount(int index,int maxVal,int asstSize) {

this.acctId = index;

this.customerName = "Milton Moneybags";

this.assets = new HashMap();

int size = asstSize;

this.netWorth = 0.0;

for (int i = 0; i < size; i++) {

FastAsset asset = new FastAsset(i,maxVal);

this.assets.put(new Integer(i), asset);

this.netWorth += asset.getValue();

}

if (encodeTimestamp) {

this.timestamp = NanoTimer.getTime();

}

}

//

public int getAcctId() {

return this.acctId;

}

public String getCustomerName() {

return this.customerName;

}

public double getNetWorth() {

return this.netWorth;

}

public void incrementNetWorth() {

++this.netWorth;

}

public Map getAssets(){

return this.assets;

}

//------------------------------------------------------------------------------

// ConfigurableObject

public int getIndex() {

return this.acctId;

}

// TimestampedObject

public long getTimestamp() {

if (encodeTimestamp) {

return this.timestamp;

} else {

return this.timestamp = 0;

}

}

public void resetTimestamp() {

if (encodeTimestamp) {

this.timestamp = NanoTimer.getTime();

} else {

this.timestamp = 0;

}

}

//------------------------------------------------------------------------------

// UpdatableObject

public synchronized void update() {

incrementNetWorth();

if (encodeTimestamp) {

resetTimestamp();

}

}

public int hashCode() {

return this.acctId;

}

public String toString() {

StringBuffer buf = new StringBuffer();

buf.append("FastAssetAccount [acctId=" + this.acctId

+ " customerName=" + this.customerName

+ " netWorth=" + this.netWorth

+ " timestamp=" + this.timestamp);

for (Iterator i = assets.keySet().iterator(); i.hasNext();) {

Object key = i.next();

buf.append(" " + key + "=" + assets.get(key));

}

return buf.toString();

}

public void toData(DataOutput out)

throws IOException {

//out.writeBoolean(this.encodeTimestamp);

out.writeInt(this.acctId);

DataSerializer.writeObject(this.customerName, out);

out.writeDouble(this.netWorth);

DataSerializer.writeObject(this.assets, out);

out.writeLong(this.timestamp);

}

public void fromData(DataInput in)

throws IOException, ClassNotFoundException {

//this.encodeTimestamp = in.readBoolean();

this.acctId = in.readInt();

this.customerName = (String)DataSerializer.readObject(in);

this.netWorth = in.readDouble();

this.assets = (Map)DataSerializer.readObject(in);

this.timestamp = in.readLong();

}

//------------------------------------------------------------------------------

//ObjectSizer

public int sizeof(Object o) {

if (o instanceof FastAssetAccount) {

FastAssetAccount obj = (FastAssetAccount) o;

int mapSize = 0;

if (obj.assets != null) {

for (Iterator i = obj.assets.keySet().iterator(); i.hasNext();) {

Object key = i.next();

FastAsset asset = (FastAsset) obj.assets.get(key);

mapSize += ObjectSizer.DEFAULT.sizeof(key) + ObjectSizer.DEFAULT.sizeof(asset) + 16; // 32-bit

// add guess at hashmap entry overhead

}

}

return ObjectSizer.DEFAULT.sizeof(obj.acctId) + ObjectSizer.DEFAULT.sizeof(obj.customerName)

+ ObjectSizer.DEFAULT.sizeof(obj.netWorth) + mapSize

+ ObjectSizer.DEFAULT.sizeof(obj.timestamp);

} else {

return ObjectSizer.DEFAULT.sizeof(o);

}

}

//------------------------------------------------------------------------------

// Delta

public boolean hasDelta() {

return true;

}

public void toDelta(DataOutput out)

throws IOException {

out.writeDouble(this.netWorth);

if (encodeTimestamp) {

out.writeLong(this.timestamp);

}

}

public void fromDelta(DataInput in)

throws IOException {

if (getBeforeUpdate) {

this.netWorth = in.readDouble();

} else {

this.netWorth += in.readDouble();

}

if (encodeTimestamp) {

this.timestamp = in.readLong();

}

}

//------------------------------------------------------------------------------

// Cloneable

/**

* Makes a deep copy of this account.

*/

public Object clone() throws CloneNotSupportedException {

DeltaFastAssetAccount acct = (DeltaFastAssetAccount)super.clone();

acct.assets = new HashMap();

for (Iterator i = this.assets.keySet().iterator(); i.hasNext();) {

Integer key = (Integer)i.next();

FastAsset asset = (FastAsset)this.assets.get(key);

acct.assets.put(key, asset.copy());

}

return acct;

}

//------------------------------------------------------------------------------

// miscellaneous

public boolean equals(Object obj) {

if (obj != null && obj instanceof DeltaFastAssetAccount) {

DeltaFastAssetAccount acct = (DeltaFastAssetAccount)obj;

if (this.acctId == acct.acctId) {

return true;

}

}

return false;

}

}