Peoplecode setting value to Null

Peoplecode setting value to Null

String

Always use space to assign a null value to a string.
e.g. &Test_Str = ” “;

Number

Use 0 (zero) to assign a null value to a number.
e.g. &Test_Num = 0;

Date

Always Use blank value to assign a null value to a date otherwise it will give you invalid date error if it is equated to null or space as string.
e.g. &Test_Date = “”;

Other Data Types

For other data types like record, rowset we can assign them to null so as to get accurate results from all() and none() functions by paasing them as parameter.
e.g. &Test_Rec = null;

Application Class Properties

We can not use all() or none() functions to check if any property of application class is set. For this we will need to check by equating it to null or blank or space or zero based on its type in a conditional statement.

Peoplecode App Class reference

http://peoplesoftlearnings.blogspot.my/2008/03/application-classes-in-peoplesoft.html

http://peoplesoftlearnings.blogspot.my/2010/03/instance-variable-in-peoplecode.html

http://jjmpsj.blogspot.my/2014/07/private-app-class-members.html

 

https://docs.oracle.com/cd/E41509_01/pt852pbh2/eng/psbooks/tpcd/chapter.htm?File=tpcd/htm/tpcd04.htm

 

Application Classes in Peoplesoft – Reference sheet / Points remember

 

  • Importing packages or classes

<Pacakge name>:<Subpacakge name>:<…>:<Class name or wild card>

 

  • Class Extensions represents the “is-a” relationship.

When a class extends another class, it’s called a subclass of that class.

 

  • No Multiple inheritances or Concept of interface in Application classes.

 

  • Instance variables in the class are accessible in all the objects of that class.

 

  • Application programs generally pass parameters by value, which is not the same as for existing functions.

 

  • Parameter passing with object data types is by reference.

 

  • When the objects are passed to method and it reassign the object with new object it will not reflected in the calling method.

 

  • Application Programs use the out specifier to pass a parameter by reference.

Method increment (&Value as number out); rem passed by reference.

 

  • Create is the key word used to create the class object.

Local MyObjectClass &o1 = Create MyobjectClass (‘A’);

Local MyObjectClass &o1 = Create Test: Examples: MyobjectClass (‘A’);

 

  • If parameter in a method is having out specifier then parameter should be a variable and cannot be constant.

 

  • A class that extends another class must have constructor, and in the constructor it must initialize its super class.

To initialize a superobject, an instance of the superclass is assigned to the keyword %Super in the constructor for the subclass.

 

Class Example extends ExampleBase

Method Example ();

End-class;

 

Method Example

%Super = create ExampleBase ();

&BaseStrin = &currentBaseString;

&Slashstring = &BaseString;

End-Method;

 

  • Before the constructor runs, the instance variables for the class are set by default takes on their declared types.

 

  • An application class doesn’t have destructors, that is, a method called just before an object is destroyed. The People code runtime environment generally cleans up any held resources.

 

  • When application class properties and instance variables are used as the argument to functions or methods, they are always passed by value, never by reference.

 

  • %This is can be used to self reference. This is to refer the same object.

 

  • %Super = %This – this should never be done it will go to an infinite loop.

 

  • Import Fruit:* – imports all the classes in the application package.

 

  • Import statements are validated when you save the Peoplecode.

 

  • Peoplesoft recommends that you use read-write or ready only properties instead of creating methods name GetXxx and SetXxx.

 

  • Getter and Setter syntax

Get Propertyname

End-get;

 

  • External Functions Declarations are allowed in application classes, in the global and component variable declarations, after the class declaration (after the end-class) and before the method definition.

 

  • %Super is only required to access superclass members that are hidden by overriding members in the current time.

 

  • Downcasting is the process of determining if an object is of a particular subclass type. If the object has that subtype (either the object is of that subtype, or is a subtype of it), a reference to the subject is returned, otherwise Null is returned. In either case, the type of the resulting value is compatible with the name subclass type.

 

  • Class Fruit

Property number fruitcount;

End-class;

 

Class Banana extends Fruit

Property number BananaCount;

End-Class;

 

Local Banana &MyBanana = Create Banana ();

Local Fruit &MyFruit = &MyBanana;   /* Okay, Banana is a subtype of Fruit */

Local number &num = & MyBanana.BananaCount;

 

&MyBanana = &MyFruit as Banana;   /* &MyFruit is currently a Banana at runtime */

&Num = (&MyFruit as Banana).BananaCount; /* same as &MyBanana.BananaCount */

&MyFruit = Create Fruit ();

&MyBanana = &MyFruit as Banana; /* Assigns Null – &Myfruit isn’t a Banana */

 

  • /* */ and /**  */ comments are allowed. Comments enclosed in  /** — */ are potentially be used to generate API documentation.

 

  • Method header comments are uses some tags which helps in API documentation

Some of the tags are

  • @Parameter N
  • @exception name
  • @return type

Class header comments contains tags

  • @version X (value of version)
  • @author  name

 

Example

 

/**

* Class header comments

* @Version 1.0

* @author Ganesh

*/

 

Import PWWPack: ExampleBase

 

Class Example extends ExampleBase

Method Example ();                                     /*Constructor*/

Method NumToStr (&Num As number) Returns string ();

Method AppendSlash ();

Property number SlashCount get;                   /*Get properties */

Property number ImportantDayofWeek get set; /*Get and set properties */

Property string Slashstring readonly;   /* values can be assigned in constructor */

Property date ImporantDate;

Private

Method NextDayofWeek (&Dow As number) returns date;

Constant &Sunday = 1;              /*Constants */

Instance string &Basestring;      /* Instance variables are like static variable */

End-class;

 

Declare function getusername Peoplecode FUNCLIB_PP.STRING_FUNCTIONS FieldFormula;

 

/**

* Method header comments example

* @param Dow is a number parameter

* @exception it throws Invalid day exception if the number is negative.

* @return   it is returns the date as of that week.

*/

Method NextDayofWeek  (&Dow)

———

———

End-method;

 

/* get block */

 

Get SlashCount

Return (Slashcount);

End-get;

 

 

– Posted by Ganesh

It might be confusing for many of them, how is instance variables different from the Private and Public variables.

Myth :- specific object (instance of a class) would only have access to its own instance variables.

Instance variable is very different to Private or Public. Infact it is not right comparison of Instance with Private and Public.

Instance variables equal to Static variables in the other Object oriented programing language (like C++ and Java).

Instance – Defines the scope of the variable where as private and public key words define access levels/Visiblity of the variables. If variable is not defined as Instance then SCOPE of the variable is Local by defult (Local to the created object of the class).

Instance – scope of the variable is across the objects of the same class and scope of the Instance variable is at the class level.

The variables are created when the first object of the class is creted and will be present till last object of the same class is present in the memory.

If the Instance variable is declared as Private it is accessed the way it is accessed i,e only with in the class methods. if variable is declared as Public it is accessed the way you access other public variables. (i,e both within the class and outside of the class).

Simple comparison that can be done..(just for understanding purpose).

Component variables has scope within the component similarly instance variables has scope at the class level across the objects of the same class.

Big question arise when do we need these kind of variables.

1) if you want to count how many objects of the class was created you increment this variable in the constructor of the class.
2) If you have constant value that needs to shared across the objects of the class then you can use the instance variables.
3) Shared variable across the objects like component variable (across the different events of the component).

 

“Private” App Class Members

I was reading Lee Greffin’s post More Fun with Application Packages — Instances and stumbled across this quote from PeopleBooks:

A private instance variable is private to the class, not just to the object instance. For example, consider a linked-list class where one instance needs to update the pointer in another instance.

What exactly does that mean? I did some testing to try and figure it out. Here is what I came up with:

  1. It is still an instance variable which means each in-memory object created from the App Class blue print has its own memory placeholder for each instance member.
  2. Instances of other classes can’t interact with private instance members.
  3. Instances of the exact same class CAN interact with private members of a different instance.
  4. Private instance members differ from static members in other languages because they don’t all share the same pointer (pointer, reference, whatever).

I thought it was worth proving so here is my sample. It is based on the example suggested in PeopleBooks:

For example, consider a linked-list class where one instance needs to update the pointer in another instance.

The linked list is just an item with a pointer to the next item (forward only). A program using it keeps a pointer to the “head” and then calls next() to iterate over the list. It is a very common pattern so I will forgo further explanation. Here is a quick implementation (in the App Package JJM_COLLECTIONS):

class ListItem
   method ListItem(&data As any);
   method linkTo(&item As JJM_COLLECTIONS:ListItem);
   method next() Returns JJM_COLLECTIONS:ListItem;
   method getData() Returns any;
private
   instance JJM_COLLECTIONS:ListItem &nextItem_;
   instance any &data_;
end-class;

method ListItem
   /+ &data as Any +/
   %This.data_ = &data;
end-method;

method linkTo
   /+ &item as JJM_COLLECTIONS:ListItem +/
   &item.nextItem_ = %This;
end-method;

method next
   /+ Returns JJM_COLLECTIONS:ListItem +/
   Return %This.nextItem_;
end-method;

method getData
   /+ Returns Any +/
   Return %This.data_;
end-method;

Notice the linkTo method sets the value of the private instance member of a remote instance (its parameter), NOT the local instance. This is what is meant by private to the class, not private to the instance. Each instance has its own &nextItem_ instance member and other instances of the exact same class can manipulate it. Here is the test case I used to test the remote manipulation implementation:

import TTS_UNITTEST:TestBase;
import JJM_COLLECTIONS:ListItem;

class TestListItem extends TTS_UNITTEST:TestBase
   method TestListItem();
   method Run();
end-class;

method TestListItem
   %Super = create TTS_UNITTEST:TestBase("TestListItem");
end-method;

method Run
   /+ Extends/implements TTS_UNITTEST:TestBase.Run +/
   Local JJM_COLLECTIONS:ListItem &item1 =
      create JJM_COLLECTIONS:ListItem("Item 1");
   Local JJM_COLLECTIONS:ListItem &item2 =
      create JJM_COLLECTIONS:ListItem("Item 2");
   
   &item2.linkTo(&item1);
   
   %This.AssertStringsEqual(&item1.next().getData(), "Item 2",
      "The next item is not Item 2");
   %This.Msg(&item1.next().getData());
end-method;

The way it is written requires you to create the second item and then call the second item’s linkTo method to associate it with the head (or previous) element.

Now, just because you CAN manipulate a private instance member from a remote instance doesn’t mean you SHOULD. Doing so seems to violate encapsulation. You could accomplish the same thing by reversing the linkTo method. What if we flipped this around so you created the second item, but called the first item’s linkTo? It is really the first item we want to manipulate in a forward only list (now, if it were a multi-direction list perhaps we would want to manipulate the &prevItem_ member?). Here is what the linkTo method would look like:

method linkTo
   /+ &item as JJM_COLLECTIONS:ListItem +/
   %This.nextItem_ = &item;
end-method;

Now what if we wanted a forward AND reverse linked list? Here is where maybe the ability to manipulate siblings starts to seem a little more reasonable (I still think there is a better way, but humor me):

class ListItem
   method ListItem(&data As any);
   method linkTo(&item As JJM_COLLECTIONS:ListItem);
   method next() Returns JJM_COLLECTIONS:ListItem;
   method prev() Returns JJM_COLLECTIONS:ListItem;
   method remove() Returns JJM_COLLECTIONS:ListItem;
   method getData() Returns any;
private
   instance JJM_COLLECTIONS:ListItem &nextItem_;
   instance JJM_COLLECTIONS:ListItem &prevItem_;
   instance any &data_;
end-class;

method ListItem
   /+ &data as Any +/
   %This.data_ = &data;
end-method;

method linkTo
   /+ &item as JJM_COLLECTIONS:ListItem +/
   REM ** manipulate previous sibling;
   &item.nextItem_ = %This;
   %This.prevItem_ = &item;
end-method;

method next
   /+ Returns JJM_COLLECTIONS:ListItem +/
   Return %This.nextItem_;
end-method;

method prev
   /+ Returns JJM_COLLECTIONS:ListItem +/
   Return %This.prevItem_;
end-method;

method remove
   /+ Returns JJM_COLLECTIONS:ListItem +/
   %This.nextItem_.linkTo(%This.prevItem_);
   REM ** Or manipulate both siblings;
   REM %This.prevItem_.nextItem_ = %This.nextItem_;
   REM %This.nextItem_.prevItem_ = %This.prevItem_;
   Return %This.prevItem_;
end-method;

method getData
   /+ Returns Any +/
   Return %This.data_;
end-method;

And here is the final test case

import TTS_UNITTEST:TestBase;
import JJM_COLLECTIONS:ListItem;

class TestListItem extends TTS_UNITTEST:TestBase
   method TestListItem();
   method Run();
end-class;

method TestListItem
   %Super = create TTS_UNITTEST:TestBase("TestListItem");
end-method;

method Run
   /+ Extends/implements TTS_UNITTEST:TestBase.Run +/
   Local JJM_COLLECTIONS:ListItem &item1 =
      create JJM_COLLECTIONS:ListItem("Item 1");
   Local JJM_COLLECTIONS:ListItem &item2 =
      create JJM_COLLECTIONS:ListItem("Item 2");
   Local JJM_COLLECTIONS:ListItem &item3 =
      create JJM_COLLECTIONS:ListItem("Item 3");
   
   &item2.linkTo(&item1);
   
   %This.AssertStringsEqual(&item1.next().getData(), "Item 2",
      "Test 1 failed. The next item is not Item 2");
   %This.AssertStringsEqual(&item2.prev().getData(), "Item 1",
      "Test 2 failed. The prev item is not Item 1");
   
   &item3.linkTo(&item2);
   %This.AssertStringsEqual(&item1.next().next().getData(), "Item 3",
      "Test 3 failed. The next.next item is not Item 3");
   %This.AssertStringsEqual(&item1.next().next().prev().getData(), "Item 2",
      "Test 4 failed. The prev item is not Item 2");
   
   Local JJM_COLLECTIONS:ListItem &temp = &item2.remove();
   %This.AssertStringsEqual(&item1.next().getData(), "Item 3",
      "Test 5 failed. The next item is not Item 3");
   %This.AssertStringsEqual(&item1.next().prev().getData(), "Item 1",
      "Test 6 failed. The prev item is not Item 1");
   
end-method;

I hope that helps clear up some of the confusion around the term “private” as it relates to Application Classes.