JCS operation arguments, pass by reference or copy?

Can I assume that objects passed from JPF into JCS, or between JCS arguments are passed by reference?
[email protected] (replace MASK with '_')

I'm asking this because the JCS may be in its own project independent of the web project, I wonder if it will still be pass by reference vs copy.
If it is pass by copy, I'll need to return beans passed into JCS operations as follows:
formBean = myControl.actionA(formBean);
[email protected] (replace MASK with '_')

Similar Messages

Using the "this" operator to pass variable references among classes and met

Hi guys still trying to understand how to use the "this" operator
can some one tell what I am doing wrong or just make this work for me to see how it works.
public class ReferencePassing
public static void main(String[]args)
ReferencePassing rp = new ReferencePassing();
System.out.println(rp);
public ReferencePassing()
HelperObject ho = new HelperObject(this);
System.out.println(this);
class HelperObject
private ReferencePassing MyReferencePassingBuddy;
public HelperObject (ReferencePassing theRp);
MyReferencePassingBuddy = theRp;
print();
public void print()
System.out.println(MyReferencePassingBuddy);
}

Hi guys still trying to understand how to use the "this" operatorYou're still trying to understand how to write methods and constructors.
public HelperObject (ReferencePassing theRp);Syntax error at ';'.
MyReferencePassingBuddy = theRp;
print();
public void print()Syntax error: '}' expected.

Confused about passing by reference and passing by valule

Hi,
I am confuse about passing by reference and passing by value. I though objects are always passed by reference. But I find out that its true for java.sql.PreparedStatement but not for java.lang.String. How come when both are objects?
Thanks

Hi,
I am confuse about passing by reference and passing
by value. I though objects are always passed by
reference. But I find out that its true for
java.sql.PreparedStatement but not for
java.lang.String. How come when both are objects?
ThanksPass by value implies that the actual parameter is copied and that copy is used as the formal parameter (that is, the method is operating on a copy of what was passed in)
Pass by reference means that the actual parameter is the formal parameter (that is, the method is operating on the thing which is passed in).
In Java, you never, ever deal with objects - only references to objects. And Java always, always makes a copy of the actual parameter and uses that as the formal parameter, so Java is always, always pass by value using the standard definition of the term. However, since manipulating an object's state via any reference that refers to that object produces the same effect, changes to the object's state via the copied reference are visible to the calling code, which is what leads some folk to think of java as passing objects by reference, even though a) java doesn't pass objects at all and b) java doesn't do pass by reference. It passes object references by value.
I've no idea what you're talking about wrt PreparedStatement, but String is immutable, so you can't change its state at all, so maybe that's what's tripping you up?
Good Luck
Lee
PS: I will venture a guess that this is the 3rd reply. Let's see...
Ok, second. Close enough.
Yeah, good on yer mlk, At least I beat Jos.
Message was edited by:
tsith

No Pass-by-Value or Copy Constructors

After having used AS3 for some months now, I've realized that
there is no pass-by-value option when passing variables into
functions. The only option is pass-by-reference. Similarly, there
are no default copy constructors. So, if I want to create a copy of
an object, I have to write code to create a new instance of the
object and manually copy all of the source variable's properties to
the new target object.
This lack of a pass-by-value mechanism and copy constructors
leads to some confusing behavior and necessitates writing quite a
bit of extra code. A common case involving confusion is when a
function call changes a property of a passed-in object. The caller
might assume that the object will not be modified and then be
surprised when it is. This is especially likely to happen when
different people are working on the caller and the callee. It
shouldn't be necessary for the caller to be concerned about the
internal workings of an object being used but, because there is no
pass-by-value mechanism, the caller often must take this into
account.
Because of the lack of a pass-by-value mechanism the onus is
on the person writing a function to always make a copy of passed-in
objects if they are going to be modified. Unfortunately, the lack
of default copy constructors makes this an onerous task. The only
way to copy an object is to write code to create a new object and
then copy each property of the object. Where the properties are
objects themselves a deep copy is needed and the amount of code can
become large and the task tedious. To do this amounts to writing a
set of copy constructors for each object and sub-object - each time
a variable is accessed for modify.
To make matters worse, it's not even possible to write a copy
constructor for user-created classes. Consider the following
attempt at writing a copy constructor to copy two instance
variables for a custom Form class:
public function Form(f:Form) {
this._textHeight = f._textHeight;
this._actionURL = f._actionURL;
This causes a "Duplicate function definition" compile error
because a default constructor already exists.
Pass-by-value and built-in copy constructors are standard
features in most OOP languages and their lack in AS3 is a glaring
omission. I hope Adobe will seriously consider adding them to the
next version of ActionScript.

Nitin_Mathur wrote:
at one time i had doubted my own conceptsNote that the type of a parameter may be different from the type of the object you created. However, it is still the same value that is passed, as pointed out by this example:
public class Test {
    public Test() {
        //an object of type "MyClass" is created on the heap with the "new" operator:
        MyClass myClass = new MyClass();
        doSomething(myClass);//the reference to the object is passed by value
    private void doSomething(MyInterface myInterface) {
        //the passed value is a reference to a "MyClass" object,
        //but here it is considered to be a "MyInterface" object
        //and we don't have access to the "MyClass"-method "testClass()"
        myInterface.testInterface();
    public static void main(String[] args) {
        new Test();
interface MyInterface {
    public void testInterface();
class MyClass implements MyInterface {
    public void testInterface() {
        System.out.println("testInterface");
    public void testClass(){
        System.out.println("testClass");
}

Pass by reference and String

public class Test {
    static void method(String str) {
        str = "String Changed";
    public static void main(String[] args) {
        String str = new String("My String");
        System.out.println(str);
        method(str);
        System.out.println(str);
}The output is
My String
My String
How this is possible when objects are passed by reference ?

> How this is possible when objects are passed by reference ?
All parameters to methods are passed "by value." In other words, values of parameter variables in a method are copies of the values the invoker specified as arguments. If you pass a double to a method, its parameter is a copy of whatever value was being passed as an argument, and the method can change its parameter's value without affecting values in the code that invoked the method. For example:
class PassByValue {
    public static void main(String[] args) {
        double one = 1.0;
        System.out.println("before: one = " + one);
        halveIt(one);
        System.out.println("after: one = " + one);
    public static void halveIt(double arg) {
        arg /= 2.0;     // divide arg by two
        System.out.println("halved: arg = " + arg);
}The following output illustrates that the value of arg inside halveIt is divided by two without affecting the value of the variable one in main:before: one = 1.0
halved: arg = 0.5
after: one = 1.0You should note that when the parameter is an object reference, the object reference -- not the object itself -- is what is passed "by value." Thus, you can change which object a parameter refers to inside the method without affecting the reference that was passed. But if you change any fields of the object or invoke methods that change the object's state, the object is changed for every part of the program that holds a reference to it. Here is an example to show the distinction:
class PassRef {
    public static void main(String[] args) {
        Body sirius = new Body("Sirius", null);
        System.out.println("before: " + sirius);
        commonName(sirius);
        System.out.println("after: " + sirius);
    public static void commonName(Body bodyRef) {
        bodyRef.name = "Dog Star";
        bodyRef = null;
}This program produces the following output: before: 0 (Sirius)
after: 0 (Dog Star)Notice that the contents of the object have been modified with a name change, while the variable sirius still refers to the Body object even though the method commonName changed the value of its bodyRef parameter variable to null. This requires some explanation.
The following diagram shows the state of the variables just after main invokes commonName:
main()            |              |
    sirius------->| idNum: 0     |
                  | name --------+------>"Sirius"
commonName()----->| orbits: null |
    bodyRef       |______________|At this point, the two variables sirius (in main) and bodyRef (in commonName) both refer to the same underlying object. When commonName changes the field bodyRef.name, the name is changed in the underlying object that the two variables share. When commonName changes the value of bodyRef to null, only the value of the bodyRef variable is changed; the value of sirius remains unchanged because the parameter bodyRef is a pass-by-value copy of sirius. Inside the method commonName, all you are changing is the value in the parameter variable bodyRef, just as all you changed in halveIt was the value in the parameter variable arg. If changing bodyRef affected the value of sirius in main, the "after" line would say "null". However, the variable bodyRef in commonName and the variable sirius in main both refer to the same underlying object, so the change made inside commonName is visible through the reference sirius.
Some people will say incorrectly that objects are passed "by reference." In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory. If the Java programming language actually had pass-by-reference parameters, there would be a way to declare halveIt so that the preceding code would modify the value of one, or so that commonName could change the variable sirius to null. This is not possible. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode -- pass by value -- and that helps keep things simple.
-- Arnold, K., Gosling J., Holmes D. (2006). The Java� Programming Language Fourth Edition. Boston: Addison-Wesley.
~

How BAPI Tables parameters are passed by reference

Hi Gurus,
I have a genuine doubt regarding BAPI parameters. I would like to point out the genreal rules of bapi like,
1. BAPI parameters should be passed by value. (Because they are rfc fm's. So both systems will be in different servers. This is the normal scenario.)
2. But the tables parameters in BAPI can't be passed by value. Instead they are passed by reference.
3. I know they use some kind of delta mechanism to transfer tables parameters to remote servers.
So gurus I would like to know what exactly happens when a tables parameter is passed. And also I didn't understand the delta mechanism. Kindly guide me.
Thanks in advance,
Jerry Jerome

You'll see in [SAP Library - RFC - Parameter Handling in Remote Calls|http://help.sap.com/saphelp_nw04s/helpdata/en/22/042551488911d189490000e829fbbd/frameset.htm] that tables are not passed by reference when you use RFC. It also explains the delta.
When you make a remote function call, the system handles parameter transfer differently than it does with local calls.
TABLES parameters
The actual table is transferred, but not the table header. If a table parameter is not specified, an empty table is used in the called function.
The RFC uses a delta managing mechanism to minimize network load during parameter and result passing. Internal ABAP tables can be used as parameters for function module calls. When a function module is called locally, a parameter tables is transferred u201Cby reference". This means that you do not have to create a new local copy. RFC does not support transfer u201Cby referenceu201D. Therefore, the entire table must be transferred back and forth between the RFC client and the RFC server. When the RFC server receives the table entries, it creates a local copy of the internal table. Then only delta information is returned to the RFC client. This information is not returned to the RFC client every time a table operation occurs, however; instead, all collected delta information is passed on at once when the function returns to the client.
The first time a table is passed, it is given an object-ID and registered as a "virtual global table" in the calling system. This registration is kept alive as long as call-backs are possible between calling and called systems. Thus, if multiple call-backs occur, the change-log can be passed back and forth to update the local copy, but the table itself need only be copied once (the first time).

Argument Passing In RMI

In case of RMI, are arguments passed by Value or passed by reference?
Please elaborate and explain as I am completely confused.

Arguments to or return values from remote methods can be of almost any type, including local objects, remote objects, and primitive types. More precisely, any entity of any type can be passed to or from a remote method as long as the entity is an instance of a type that is a primitive data type, a remote object, or a serializable object, which means that it implements the interface java.io.Serializable.
A few object types do not meet any of these criteria and thus cannot be passed to or returned from a remote method. Most of these objects, such as a file descriptor, encapsulate information that makes sense only within a single address space. Many of the core classes, including those in the packages java.lang and java.util, implement the Serializable interface.
The rules governing how arguments and return values are passed are as follows.
Remote objects are essentially passed by reference. A remote object reference is a stub, which is a client-side proxy that implements the complete set of remote interfaces that the remote object implements.
Local objects are passed by copy, using object serialization. By default all fields are copied, except those that are marked static or transient. Default serialization behavior can be overridden on a class-by-class basis.
Passing an object by reference (as is done with remote objects) means that any changes made to the state of the object by remote method calls are reflected in the original remote object. When passing a remote object, only those interfaces that are remote interfaces are available to the receiver; any methods defined in the implementation class or defined in nonremote interfaces implemented by the class are not available to that receiver.

Argument Passing

I have probably a very simple question. I'm passing the arguments by call-by-reference and after the 1st using of the methods, a and b are changed (this is normal), but how can i make it without changing their initial values.
I think the soltution is something very basic for java, but i'm new to java and i need help :)
public static void main(String args[])
    Rational a = new Rational(10, 20);
    Rational b = new Rational(30, 10);
    Rational rez = new Rational(0, 1);
    rez = a.add(b);
    System.out.println(":\n"+rez.num+"\n-\n"+rez.den);
    rez = a.sub(b);
    System.out.println(" \n"+rez.num+"\n-\n"+rez.den);
    rez = a.mul(b);
    System.out.println(" \n"+rez.num+"\n-\n"+rez.den);
    rez = a.div(b);
    System.out.println(" \n"+rez.num+"\n-\n"+rez.den);
      }Maybe the right question is: how this code could work without a and b changing their values after calling the methods.
P.S. I hope you understand what I'm asking. Sorry for my bad English
Edited by: asemenea on Jul 28, 2008 10:38 AM

I'm not very good at English and I understood wrong what I read from Schildt:Rule #1: Don't use Schildt as a source of Java expertise.
All parameters to methods are passed "by value." In other words, values of parameter variables in a method are copies of the values the invoker specified as arguments. If you pass a double to a method, its parameter is a copy of whatever value was being passed as an argument, and the method can change its parameter's value without affecting values in the code that invoked the method. For example:
class PassByValue {
    public static void main(String[] args) {
        double one = 1.0;
        System.out.println("before: one = " + one);
        halveIt(one);
        System.out.println("after: one = " + one);
    public static void halveIt(double arg) {
        arg /= 2.0;     // divide arg by two
        System.out.println("halved: arg = " + arg);
}The following output illustrates that the value of arg inside halveIt is divided by two without affecting the value of the variable one in main:before: one = 1.0
halved: arg = 0.5
after: one = 1.0You should note that when the parameter is an object reference, the object reference -- not the object itself -- is what is passed "by value." Thus, you can change which object a parameter refers to inside the method without affecting the reference that was passed. But if you change any fields of the object or invoke methods that change the object's state, the object is changed for every part of the program that holds a reference to it. Here is an example to show the distinction:
class PassRef {
    public static void main(String[] args) {
        Body sirius = new Body("Sirius", null);
        System.out.println("before: " + sirius);
        commonName(sirius);
        System.out.println("after: " + sirius);
    public static void commonName(Body bodyRef) {
        bodyRef.name = "Dog Star";
        bodyRef = null;
}This program produces the following output: before: 0 (Sirius)
after: 0 (Dog Star)Notice that the contents of the object have been modified with a name change, while the variable sirius still refers to the Body object even though the method commonName changed the value of its bodyRef parameter variable to null. This requires some explanation.
The following diagram shows the state of the variables just after main invokes commonName:
main()            |              |
    sirius------->| idNum: 0     |
                  | name --------+------>"Sirius"
commonName()----->| orbits: null |
    bodyRef       |______________|At this point, the two variables sirius (in main) and bodyRef (in commonName) both refer to the same underlying object. When commonName changes the field bodyRef.name, the name is changed in the underlying object that the two variables share. When commonName changes the value of bodyRef to null, only the value of the bodyRef variable is changed; the value of sirius remains unchanged because the parameter bodyRef is a pass-by-value copy of sirius. Inside the method commonName, all you are changing is the value in the parameter variable bodyRef, just as all you changed in halveIt was the value in the parameter variable arg. If changing bodyRef affected the value of sirius in main, the "after" line would say "null". However, the variable bodyRef in commonName and the variable sirius in main both refer to the same underlying object, so the change made inside commonName is visible through the reference sirius.
Some people will say incorrectly that objects are passed "by reference." In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory. If the Java programming language actually had pass-by-reference parameters, there would be a way to declare halveIt so that the preceding code would modify the value of one, or so that commonName could change the variable sirius to null. This is not possible. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode -- pass by value -- and that helps keep things simple.
-- Arnold, K., Gosling J., Holmes D. (2006). The Java? Programming Language Fourth Edition. Boston: Addison-Wesley.
~

Arrays are passed by reference or value ?

Hi peoples,
I have something interesting here which I need to know. Look into the following classes :
     public class example1 {
     int i[] = {0};
     public static void main(String args[]) {
     int i[] = {1};
     change_i(i);
     System.out.println(i[0]);
     public static void change_i(int i[]) {
     i[0] = 2;
     i[0] *= 2;
     public class example2 {
     int i[] = {0};
     public static void main(String args[]) {
     int i[] = {1};
     change_i(i);
     System.out.println(i[0]);
     public static void change_i(int i[]) {
     int j[] = {2};
     i = j;
Among the above classes, the class named 'example1' returns the value 4 whereas, the class named 'example2' returns the value 1.
Any explanations to this one please....
Cheers,
Rasmeet

minglu, you are not doing right.
i just don't get it why you have i[] as instance variable but never use it ( i[] is declared in every method so each i you refer to in the method is a local varable not member variable that can be shared for the object ).
your first solution work. but that i = j line is not needed because it has no effect you still cannot change the referrence of i to other int[]. your first soultion just need to be
public static int[] change_i(int i[]) {
int j[] = {2};
return j;
}anyway, using this solution, the method name will be misleading because the method didnot change i in anyway. i is changed because you assign the return array (j) to i.
for that second solution also, you didn't use your member variable i at all. what you change is the content of i you pass so the result is correct. but then how is this method different from the first method the original poster posted?
moreover, java never pass argument to the method by reference it ALWAYS pass by copy.i suppose you define passing by reference in the same way C++ does. all object variable in java is a refernce to Object so passing the variable to method is surely passing the reference to the method but that's not passing by reference. it's passing by copy because what is passed is the copy of the reference to the object, not the reference to the reference to Object. if it is really passing by refernce, then you will be able to change your reference to object to point anywhere because you have the access the address of the reference. but since you don't (you only know where the passed reference is pointing to (you have the COPY of value of reference) but you don't know where the refernce store its value) you can only change the content of the pointed object but not changing the pointed object.
let me restate this, java always pass by reference.

Calrification on Pass by reference

Hi All,
In java, if we are passing an object to a function actually we are passing the reference. So, if the function is doing any manipulation on the Object reference, it will affect the passing object.
For example,
class Ob1
     int i=0;
public class Ref
     public static void main(String a[])
          Ob1 o=new Ob1();
          System.out.println("Before calling :"+o.i);
          call(o);
          System.out.println("After calling :"+o.i);
     static void call(Ob1 o)
          o.i++;
Is it possible to get the original value of i(object Ob1) after calling call()?
Thanks in advance
+Sha

> In java, if we are passing an object to a function
actually we are[b] passing the reference.
By value.
Is it possible to get the original value of i(object
Ob1) after calling call()?
Store the original value in a local variable.
And please note the following:
All parameters to methods are passed "by value." In other words, values of parameter variables in a method are copies of the values the invoker specified as arguments. If you pass a double to a method, its parameter is a copy of whatever value was being passed as an argument, and the method can change its parameter's value without affecting values in the code that invoked the method. For example:
class PassByValue {
    public static void main(String[] args) {
        double one = 1.0;
        System.out.println("before: one = " + one);
        halveIt(one);
        System.out.println("after: one = " + one);
    public static void halveIt(double arg) {
        arg /= 2.0;     // divide arg by two
        System.out.println("halved: arg = " + arg);
}The following output illustrates that the value of arg inside halveIt is divided by two without affecting the value of the variable one in main:before: one = 1.0
halved: arg = 0.5
after: one = 1.0You should note that when the parameter is an object reference, the object reference -- not the object itself -- is what is passed "by value." Thus, you can change which object a parameter refers to inside the method without affecting the reference that was passed. But if you change any fields of the object or invoke methods that change the object's state, the object is changed for every part of the program that holds a reference to it. Here is an example to show the distinction:
class PassRef {
    public static void main(String[] args) {
        Body sirius = new Body("Sirius", null);
        System.out.println("before: " + sirius);
        commonName(sirius);
        System.out.println("after: " + sirius);
    public static void commonName(Body bodyRef) {
        bodyRef.name = "Dog Star";
        bodyRef = null;
}This program produces the following output: before: 0 (Sirius)
after: 0 (Dog Star)Notice that the contents of the object have been modified with a name change, while the variable sirius still refers to the Body object even though the method commonName changed the value of its bodyRef parameter variable to null. This requires some explanation.
The following diagram shows the state of the variables just after main invokes commonName:
main()            |              |
    sirius------->| idNum: 0     |
                  | name --------+------>"Sirius"
commonName()----->| orbits: null |
    bodyRef       |______________|At this point, the two variables sirius (in main) and bodyRef (in commonName) both refer to the same underlying object. When commonName changes the field bodyRef.name, the name is changed in the underlying object that the two variables share. When commonName changes the value of bodyRef to null, only the value of the bodyRef variable is changed; the value of sirius remains unchanged because the parameter bodyRef is a pass-by-value copy of sirius. Inside the method commonName, all you are changing is the value in the parameter variable bodyRef, just as all you changed in halveIt was the value in the parameter variable arg. If changing bodyRef affected the value of sirius in main, the "after" line would say "null". However, the variable bodyRef in commonName and the variable sirius in main both refer to the same underlying object, so the change made inside commonName is visible through the reference sirius.
Some people will say incorrectly that objects are passed "by reference." In programming language design, the term pass by reference properly means that when an argument is passed to a function, the invoked function gets a reference to the original value, not a copy of its value. If the function modifies its parameter, the value in the calling code will be changed because the argument and parameter use the same slot in memory. If the Java programming language actually had pass-by-reference parameters, there would be a way to declare halveIt so that the preceding code would modify the value of one, or so that commonName could change the variable sirius to null. This is not possible. The Java programming language does not pass objects by reference; it passes object references by value. Because two copies of the same reference refer to the same actual object, changes made through one reference variable are visible through the other. There is exactly one parameter passing mode -- pass by value -- and that helps keep things simple.
-- Arnold, K., Gosling J., Holmes D. (2006). The Java� Programming Language Fourth Edition. Boston: Addison-Wesley.

Drag and Drop - Transferable, how to pass a reference? (URGENT)

I've a tree that supports drag and drop correctly but every time I exchange a node position the old parent instance remaining on the tree is different from the one I was referencing with the dragged child before the drag occurred. I absolutely need to maintain all references and cannot work with copies.
Is there any way to use the Transferable interface to pass the original object instead of a copy?
Thanks to Tedhill who raised the problem, trying to get a quick answer.
;o)

hi guys let me close this thread:
Thanks to asjf and sergey35 who helped me.
Actually the isDataFlavorSupported method you suggest passes a reference and not a copy.
Too bad I fell into another problem with the reloading of the
moving-node Object after the DnD.
But finally the working code is:
public class XJTreeDnD extends XJTree implements DragGestureListener, DragSourceListener, DropTargetListener{
private DefaultMutableTreeNode dragNode = null;
private TreePath dragParentPath = null;
private TreePath dragNodePath = null;
private DragSource dragSource;
private DropTarget dropTarget;
private TransferableTreePath transferable;
private boolean DnDEnabled = true;
//private boolean CnPEnabled = false;
public XJTreeDnD(XNode node) {
    super(node);
    // Set up the tree to be a drop target.
    dropTarget = new DropTarget(this, DnDConstants.ACTION_MOVE, this, true);
    // Set up the tree to be a drag source.
    dragSource = DragSource.getDefaultDragSource();
    dragSource.createDefaultDragGestureRecognizer(this, DnDConstants.ACTION_MOVE, this);
private DefaultMutableTreeNode getTreeNode(Point location) {
    TreePath treePath = getPathForLocation(location.x, location.y);
    if (treePath != null) {
      return((DefaultMutableTreeNode) treePath.getLastPathComponent());
    } else {
      return(null);
//dragGesture implementation
    public void dragGestureRecognized(DragGestureEvent e) {
      if(DnDEnabled){
        TreePath path = this.getSelectionPath();
        if (path == null || path.getPathCount() <= 1) {
          System.out.println("Error: Path null, or trying to move the Root.");
          return;
        dragNode = (DefaultMutableTreeNode) path.getLastPathComponent();
        dragNodePath = path;
        dragParentPath = path.getParentPath();
        transferable = new TransferableTreePath(path);
        // Start the drag.
        e.startDrag(DragSource.DefaultMoveDrop, transferable, this);
//dragSource implementation
    public void dragDropEnd(DragSourceDropEvent e) {
      try {
        if (e.getDropSuccess()) {
          ((BaseXJTreeModel)this.getModel()).removeNodeFromParent(dragNode);
          DefaultMutableTreeNode dragParent = (DefaultMutableTreeNode) dragParentPath.getLastPathComponent();
          XNode xnodeParent = (XNode)dragParent.getUserObject();
          ((BaseXJTreeModel)this.getModel()).valueForPathChanged(dragParentPath, xnodeParent);
      } catch (Exception ex) {
        ex.printStackTrace();
    public void dragEnter(DragSourceDragEvent e) {
      // Do Nothing.
    public void dragExit(DragSourceEvent e) {
      // Do Nothing.
    public void dragOver(DragSourceDragEvent e) {
      // Do Nothing.
    public void dropActionChanged(DragSourceDragEvent e) {
      // Do Nothing.
//dropTarget implementation
    public void drop(DropTargetDropEvent e) {
      try {
        Point dropLocation = e.getLocation();
        DropTargetContext dtc = e.getDropTargetContext();
        XJTreeDnD tree = (XJTreeDnD) dtc.getComponent();
        TreePath parentPath = tree.getClosestPathForLocation(dropLocation.x, dropLocation.y);
        DefaultMutableTreeNode parent = (DefaultMutableTreeNode)parentPath.getLastPathComponent();
        Transferable data = e.getTransferable();
        DataFlavor[] flavors = data.getTransferDataFlavors();
        for (int i=0;i<flavors.length;i++) {
          if (data.isDataFlavorSupported(flavors)) {
e.acceptDrop(DnDConstants.ACTION_MOVE);
TreePath movedPath = (TreePath) data.getTransferData(flavors[i]);
DefaultMutableTreeNode treeNodeMoved = (DefaultMutableTreeNode) movedPath.getLastPathComponent();
DefaultMutableTreeNode treeNodeLeft = (DefaultMutableTreeNode) this.dragNodePath.getLastPathComponent();
XNode xnodeParent = (XNode)parent.getUserObject();
XNode xnodeChild = (XNode)treeNodeLeft.getUserObject();
/** @todo check the parent whether to allow the drop or not */
if(xnodeParent.getPath().startsWith(xnodeChild.getPath())){
System.out.println("cannot drop a parent node on one of its children");
return;
if(xnodeParent.getPath().getPath().equals((xnodeChild.getPath().getParentPath()))){
System.out.println("node is already child of selected parent");
return;
// Add the new node to the current node.
xnodeParent.addChild(xnodeChild);
((BaseXJTreeModel)this.getModel()).valueForPathChanged(parentPath, xnodeParent);
((BaseXJTreeModel)this.getModel()).insertNodeInto(treeNodeMoved, parent, parent.getChildCount());
((BaseXJTreeModel)this.getModel()).valueForPathChanged(movedPath, xnodeChild);
e.dropComplete(true);
} else {
System.out.println("drop rejected");
e.rejectDrop();
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (UnsupportedFlavorException ufe) {
ufe.printStackTrace();
public void dragEnter(DropTargetDragEvent e) {
if (isDragOk(e) == false) {
e.rejectDrag();
return;
e.acceptDrag(DnDConstants.ACTION_MOVE);
public void dragExit(DropTargetEvent e) {
// Do Nothing.
public void dragOver(DropTargetDragEvent e) {
Point dragLocation = e.getLocation();
TreePath treePath = getPathForLocation(dragLocation.x, dragLocation.y);
if (isDragOk(e) == false || treePath == null) {
e.rejectDrag();
return;
// Make the node active.
setSelectionPath(treePath);
e.acceptDrag(DnDConstants.ACTION_MOVE);
public void dropActionChanged(DropTargetDragEvent e) {
if (isDragOk(e) == false) {
e.rejectDrag();
return;
e.acceptDrag(DnDConstants.ACTION_MOVE);
private boolean isDragOk(DropTargetDragEvent e) {
/** @todo gestire i casi in cui il drop non sia concesso */
return (true);
public void setDragAndDropEnabled(boolean enabled){
this.DnDEnabled = enabled;
public boolean isDragAndDropEnabled(){
return this.DnDEnabled;
Thanks again.
flat

Passing control reference to subVI crashes labview

Hi,
using a image control (as indicator) provided by imaq Vision, I tried to pass the reference of the control to a subVI. On a computer it works and on a other (same labview version, same vision version, same os, same hardware and hardware drivers!), this crashes labview. I tried to close the control refnum at the end of the subVI, but that changed nothing to the issue. Now I use the reference as a global variable and it seems to work...nevertheless, I would like to understand what the issue and if I should remove any passing to subVI of control ref because this can potentially triggers an error. My correlated question is if this global passing is a "fake" workaround or have real chance of improving (this before going through the whole code for changing all passing of reference to subVI)
thanks a lot

Hi,
thank CoastalMaineBird for your answer
How do you know it's this issue which causes the crash?
When I remove this parameter from and the only property node in the subVi that write to it, I have no longer any problem. Moreover, to ensure that's really the "passing", and made a global variable containing the reference to this control and use my original SubVi that do access the control through its reference number
, and it works! In this last exemple, the only change is the way of transmitting the reference
What LabVIEW version?
8.0.1
up to date according Measurement & Automation update tool
Given that one computer works OK, and another crashes, I would say that
you are seeing the effect of something else, not the cause. If passing
a control ref via terminals was fatal, it would be fatal all the time.
You have some other sort of issue, perhaps timing of the different
machines triggers the bug, perhaps running out of memory, perhaps
LabVIEW is corrupted on one machine.... But I don't think changing all
your code to use globals would solve the real problem. Actually, saying that I wonder about problem of synchronisation. I know from Visual C++ that this kind of error happens if two process try to access the same control at the same time. This is typically an error changing from a computer to an other, and mutex or semaphore are the way to deal nicely with that. But does labview contains already such a securisation? If so, the global variable point on a single object and can "fell" the semaphore/mutex. But passing make a copy that will likely have two different semaphore/mutex but will point to a single control! Do someone know if I'm wrong in this idea or not?
Thanks

Passing object references to methods

i got the Foo class a few minutes ago from the other forum, despite passing the object reference to the baz method, it prints "2" and not "3" at the end.
but the Passer3 code seems to be different, "p" is passed to test() , and the changes to "pass" in the test method prints "silver 7".
so i'm totally confused about the whole call by reference thing, can anyone explain?
class Foo {
    public int bar = 0;
    public static void main(String[] args) {
            Foo foo = new Foo();
            foo.bar = 1;
            System.out.println(foo.bar);
            baz(foo);
            // if this was pass by reference the following line would print 3
            // but it doesn't, it prints 2
            System.out.println(foo.bar);
    private static void baz(Foo foo) {
        foo.bar = 2;
        foo = new Foo();
        foo.bar = 3;
class Passer2 {
     String str;
     int i;
     Passer2(String str, int i) {
     this.str = str;
     this.i = i;
     void test(Passer2 pass) {
     pass.str = "silver";
     pass.i = 7;
class Passer3 {
     public static void main(String[] args) {
     Passer2 p = new Passer2("gold", 5);
     System.out.println(p.str+" "+p.i); //prints gold 5
     p.test(p);
     System.out.println(p.str+" "+p.i);   //prints silver 7
}

private static void baz(Foo foo) {
foo.bar = 2;
foo = new Foo();
foo.bar = 3;This sets the bar variable in the object reference by
foo to 2.
It then creates a new Foo and references it by foo
(foo is a copy of the passed reference and cannot be
seen outside the method).
It sets the bar variable of the newly created Foo to
3 and then exits the method.
The method's foo variable now no longer exists and
now there is no longer any reference to the Foo
created in the method.thanks, i think i followed what you said.
so when i pass the object reference to the method, the parameter is a copy of that reference, and it can be pointed to a different object.
is that correct?

How to pass file reference to c

Hi,
I want to pass file reference pointer to a dll written in visual c++. How can i do that?

What do you want to do with that reference in your C code? if you want to access it using OS File IO functions you have to be very careful! You should not mix LabVIEW nodes and OS platforms calls together. It's either one or the other.
If you can guarantee that what you want to do is configure the Call Library Node (CLN) parameter to Adapt To Type. Then right click on the CLN and select "Create C Source Header" or something to that meaning. Save the resulting file to disk. Open it and copy the function prototype into your C/C++ file. There should be a parameter typed LVRefnum *. Now you can use the LabVIEW manager C function MgErr FRefNumToFD(LVRefNum refNum, File *fdp);
You need to link your DLL with labview.lib in the cintools directory in order to be able to call the FRefNumToFD() function. The value in the fdp reference is the platform specific file handle, so for Windows this is a HANDLE.
Rolf Kalbermatter
CIT Engineering Netherlands
a division of Test & Measurement Solutions

Pass by Reference automatically?

In Java, are objects passed by reference automatically?
Basically, if I pass an object into a method and the method modifies the object, will the original object reflect that modification?

They're not objects. They're primitive data types. Objects require you to use new when you create and instance of them. Primitives are automatically allocated space when you declare them. Also, they are not passed by reference... only a copy of them is passed on the methods

JCS operation arguments, pass by reference or copy?

Similar Messages

Maybe you are looking for