Sergey Arnaut

Greenhorn

+ Follow

news 7 Posts 0 Threads

since Nov 03, 2008

Merit badge: grant badges

For More

Cows and Likes

Cows

Total received

In last 30 days

Forums and Threads

Recent posts by Sergey Arnaut

Using XML for string message

Why cant you use xsd schema? It can define the max and min length of element text and attribute. Or you can possibly use DTD.
And the most "stupid" variant. Every time you pass the XML you can add "rule" tags, for example:

[ November 25, 2008: Message edited by: Sergey Arnaut ]

16 years ago

OO, Patterns, UML and Refactoring

Please suggest some good solution.

0_0 it`s just mistake...
Hardworking on friday evenings... You know this...
)))))))

16 years ago

OO, Patterns, UML and Refactoring

Please suggest some good solution.

Lightweigth pattern. Even examples of use for this pattern show such situation .

16 years ago

OO, Patterns, UML and Refactoring

Not totally relying on UML

Before UML people used IDEF group, from ICAM family. Or may be SADT.
Thanks to US Air Defence))))))

As of 1995 methods 5 through 14 have not been pursued in depth.[2]
Methods:
IDEF0 : Function modeling
IDEF1 : Information Modeling
IDEF1X : Data Modeling
IDEF2 : Simulation Model Design
IDEF3 : Process Description Capture
IDEF4 : Object-Oriented Design
IDEF5 : Ontology Description Capture
IDEF6 : Design Rationale Capture
IDEF7 : Information System Auditing
IDEF8 : User Interface Modeling
IDEF9 : Scenario-Driven IS Design
IDEF10 : Implementation Architecture Modeling
IDEF11 : Information Artifact Modeling
IDEF12 : Organization Modeling
IDEF13 : Three Schema Mapping Design
IDEF14 : Network Design

Main difference is that IDEF is hard to reuse. If something was changed in model - we must redesign the whole model (In UML we can divide model into independent blocks, which can act independently). That`s why there were need to UML was created.

But I think IDEF model is good too. It`s more comlex to learn, but more simple to understand for specialists.

For using IDEF, I think best programm is BPwin. I designed there IDEF0,IDEF1 and IDEF3 models.

[ November 21, 2008: Message edited by: Sergey Arnaut ]
[ November 21, 2008: Message edited by: Sergey Arnaut ]

16 years ago

OO, Patterns, UML and Refactoring

Iterator Pattern

Here is example:

/**
* @(#)ArrayCollection.java 1.0 20/03/2008
*
* Copyright (c) Arnaut Sergey
*/
package labwork.task5;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* This class represents ArrayCollection class.
*
* @author Arnaut Sergey
*/
public class ArrayCollection<E> implements interfaces.task5.ArrayCollection<E> {
/**
* The array buffer into which the elements of the ArrayList
* are stored. The capacity of the ArrayList is the length of
* this array buffer.
*/
private transient E[] array;
/**
* The size of the ArrayList (the number of elements it
* contains).
*
* @serial
*/
private int size;
/**
* The array buffer into which the elements of the ArrayList
* are stored. The capacity of the ArrayList is the length of
* this array buffer.
*/
private transient int modCount = 0;
/**
* Constructs an empty list with the specified initial
* capacity.
*
* @param initialCapacity
* the initial capacity of the list.
*/
public ArrayCollection(int initialCapacity) {
super();
if (initialCapacity < 0) {
throw new IllegalArgumentException("Illegal Capacity: "
+ initialCapacity);
}
this.array = (E[]) new Object[initialCapacity];
}
/**
* Returns the array representation of ArrayCollection.
*
* @return Object[] array
*/
public Object[] getArray() {
return this.array;
}
/**
* Sets the array representation of ArrayCollection.
*
* @param arg0
* Array that is must be set as ArrayCollection
*/
public void setArray(E[] arg0) {
if (arg0 == null) {
throw new NullPointerException();
}
this.array = arg0;
}
/**
* Adds an element to the ArrayCollection.
*
* @param o
* Element needed to be added
*
* @return <code>true</code> (as per general Contract of
* Collection.add)
*/
public boolean add(Object o) {
ensureCapacity(size + 1);
array[size++] = (E) o;
return true;
}
/**
* Retains only the elements in this collection that are
* contained in the specified collection (optional operation).
* In other words, removes from this collection all of its
* elements that are not contained in the specified
* collection.
*
* @param c
* elements to be retained in this collection.
* @return <tt>true</tt> if this collection changed as a
* result of the call.
*/
public boolean retainAll(Collection<?> c) {
if (c == null) {
throw new NullPointerException(
"Collection needed but 'null' recieved");
}
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* Appends all of the elements in the specified Collection to
* the end of this list, in the order that they are returned
* by the specified Collection's Iterator. The behavior of
* this operation is undefined if the specified Collection is
* modified while the operation is in progress. (This implies
* that the behavior of this call is undefined if the
* specified Collection is this list, and this list is
* nonempty.)
*
* @param c
* the elements to be inserted into this list.
* @return <tt>true</tt> if this list changed as a result of
* the call.
*/
public boolean addAll(Collection<? extends E> c) {
if (c.getClass().isInstance(this)) {
throw new IllegalArgumentException();
}
ensureCapacity(size + c.toArray().length); // Increments
// modCount
System.arraycopy(c.toArray(), 0, array, size,
c.toArray().length);
size += c.toArray().length;
return c.toArray().length != 0;
}
/**
* Returns <tt>true</tt> if this collection contains all of
* the elements in the specified collection.
*
* @param c
* collection to be checked for containment in
* this collection.
* @return <tt>true</tt> if this collection contains all of
* the elements in the specified collection.
*/
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext()) {
if (!contains(e.next())) {
return false;
}
}
return true;
}
/**
* Increases the capacity of this <tt>ArrayList</tt>
* instance, if necessary, to ensure that it can hold at least
* the number of elements specified by the minimum capacity
* argument.
*
* @param minCapacity
* the desired minimum capacity.
*/
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = array.length;
if (minCapacity > oldCapacity) {
Object[] oldData = array;
int newCapacity = oldCapacity + 1;
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
array = (E[]) new Object[newCapacity];
System.arraycopy(oldData, 0, array, 0, size);
}
}
/**
* Decreases the capacity of this <tt>ArrayList</tt>
* instance.
*
*/
public void encloseCapacity() {
modCount++;
Object[] oldData = array;
int newCapacity = array.length - 1;
this.size--;
if (size != 0) {
array = (E[]) new Object[newCapacity];
} else {
this.setArray((E[]) new Object[0]);
}
System.arraycopy(oldData, 0, array, 0, size);
}
/**
* Removes all of the elements from the array.
*
* @param No
*/
public void clear() {
this.array = (E[]) new Object[0];
size = 0;
}
/**
* Checks contains element in the array.
*
* @param elem
* An element is checked for a presence
*
* @return <code>true</code> if element is contained in
* collection. <code>false</code> if element is not
* contained in collection
*/
public boolean contains(Object elem) {
return indexOf(elem) >= 0;
}
/**
* Searches for the first occurence of the given argument,
* testing for equality using the <tt>equals</tt> method.
*
* @param elem
* an object.
* @return the index of the first occurrence of the argument
* in this list; returns <tt>-1</tt> if the object
* is not found.
*/
public int indexOf(Object elem) {
if (elem == null) {
for (int i = 0; i < size; i++) {
if (array[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (elem.equals(array[i])) {
return i;
}
}
}
return -1;
}
/**
* Checks collection for emptiness.
*
* @param No
*
* @return <code>true</code> if collection is empty.
* <code>false</code> if collection is not empty.
*/
public boolean isEmpty() {
return size == 0;
}
/**
* Creates new iterator for this collection.
*
* @param No
*
* @return new Iterator
*/
public Iterator<E> iterator() {
return new ArrayIterator();
}
/**
* Removes element from collection.
*
* @param o
* Element needed to be removed
*
* @return <code>true</code> if element is removed.
* <code>false</code> if element is not removed.
*/
public boolean remove(Object o) {
for (int index = 0; index < size; index++) {
if (o.equals(array[index])) {
fastRemove(index);
return true;
}
}
return false;
}
/**
* Removes from this collection all of its elements that are
* contained in the specified collection (optional operation).
*
* @param c
* elements to be removed from this collection.
* @return <tt>true</tt> if this collection changed as a
* result of the call.
*/
public boolean removeAll(Collection<?> c) {
if (c == null) {
throw new NullPointerException("Collection nee"
+ "ded but 'null' receaved");
}
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* Private remove method that skips bounds checking and does
* not return the value removed.
*/
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0) {
System.arraycopy(array, index + 1, array, index,
numMoved);
}
encloseCapacity();
}
/**
* Returns the size of collection.
*
* @param No
* @return the size of collection
*/
public int size() {
return this.size;
}
/**
* Returns an array representation of this collection.
*
* @param No
* @return array
*/
public Object[] toArray() {
return this.array;
}
/**
* Returns an array containing all of the elements in this
* list in the correct order; the runtime type of the returned
* array is that of the specified array.
*
* @param <T>
* Generic type
* @param a
* the array into which the elements of the
* list are to be stored, if it is big enough;
* otherwise, a new array of the same runtime
* type is allocated for this purpose.
* @return array
*/
public <T> T[] toArray(T[] a) {
if (a.length < size) {
a = (T[]) java.lang.reflect.Array.newInstance(a
.getClass().getComponentType(), size);
}
System.arraycopy(array, 0, a, 0, size);
if (a.length > size) {
a[size] = null;
}
return a;
}
/**
* Returns an element of collection specified by index.
*
* @param index
* Specifies an element in the collection.
* @return element specified by index
*/
public E get(int index) {
rangeCheck(index);
return array[index];
}
/**
* Check if the given index is in range. If not, throw an
* appropriate runtime exception. This method does *not* check
* if the index is negative: It is always used immediately
* prior to an array access, which throws an
* ArrayIndexOutOfBoundsException if index is negative.
*/
private void rangeCheck(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException("Index: " + index
+ ", Size: " + size);
}
}
/**
* Creates new ArrayCollection.
*/
public ArrayCollection() {
this(0);
}
private class ArrayIterator implements
interfaces.task5.ArrayIterator<E>, Iterator<E> {
/**
* Index of element to be returned by subsequent call
* to next.
*/
private int cursor = 0;
/**
* Index of element returned by most recent call to
* next or previous. Reset to -1 if this element is
* deleted by a call to remove.
*/
private int lastRet = -1;
/**
* The modCount value that the iterator believes that
* the backing List should have. If this expectation
* is violated, the iterator has detected concurrent
* modification.
*/
private int expectedModCount = modCount;
public boolean hasNext() {
return cursor < size();
}
public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}
public void remove() {
if (lastRet == -1) {
throw new IllegalStateException();
}
checkForComodification();
try {
ArrayCollection.this
.remove(ArrayCollection.this
.get(lastRet));
if (lastRet < cursor) {
cursor--;
}
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
public Object[] getArray() {
return ArrayCollection.this.toArray();
}
public ArrayIterator() {
}
}
}

Any questions?

16 years ago

OO, Patterns, UML and Refactoring

Iterator Pattern

The java implementationof iterator pattern allows user to traverse carious types of data sets without worrying about the underlying implementation of collection. Since clients simply interact with the iterator for themselves. Some will allow full access to the underlying data sets while others may restrict certain functionalities, such as removing items.

---- "Design patterns" by Jason McDonald

For example, just open src.zip in your JAVA_HOME or whait a few ours till I found my old examples

16 years ago

OO, Patterns, UML and Refactoring

Design Query

Can you specify the main purpose of you being designed program?
The main idea of patterns, that they can be best use in specific situations.

16 years ago

OO, Patterns, UML and Refactoring