APPLICATION PACKAGES

PRESENTED BY, P.S.S.SWAMY.

What is an application package. What is an application class. Object oriented concepts. Understanding application packages &classes. Process for creating packages and classes in Application designer. Application class structure. How to use this packages and classes in people code.(import declaration). Access controls. Definition of methods. Abstract methods and properties. Interfaces. Constructors. Get/set methods &read only read write. Exception Handling.

Application packages & Application Classes

Application package is a container for application subpackages and application classes, which will  provide a hierarchical structure to your People Code programs and help you extend the common functionality of existing People Code classes (Rowset, Array, and so on) from one application to another. 

Application package

App Class is a People Code Program at base level Application classes are mainly used for reusability. Application classes people code supports object oriented programming.

i .e it supports:

Application class

Classes and Objects.Encapsulation.Abstraction.Polymorphism.Inheritance.

Class : Class is a blueprint of the object .It consists of variable and methods. class doesn’t occupy any memory. ex: Class is a map for building the house.

Object : Object is a real entity any thing physically exists in the world is called an object. But in programming languages object is instance of a class .It occupies some memory. ex: Object is house.

Encapsulation : It’s came from the word capsule . It is a property to bind the variable and methods and

also it hides the internal structure. It prevents clients from seeing the inside view. We can achieve abstraction through encapsulation.

ex : car driver doesn’t know what is the functionality when gear is changed one level to another level . But he change the gear against to the speed.

Object Oriented concepts

Abstraction :

Abstraction is process it allows to show the essential object information to the user i.e hide the non essential object information. We can achieve this through encapsulation.

Inheritance:

 It is one of the most important feature of Object Oriented Programming. It is the concept that is used for reusability purpose. Inheritance is the mechanism through which we can derived classes from other classes. The derived class is called as child class or subclass.  The class from which the subclass is derived is called a superclass (also a base class or a parent class).

Polymorphism :

A method having different forms is called polymorphism i.e method having the same name but we can perform different tasks by using this polymorphism.

We have to concepts here

1.method overloading.

2.method overriding.

Object Oriented concepts

Application classes have a fully qualified name that is formed hierarchically by the name of the top-level package. It means we can give the same name of different classes but the fully qualified name of the class must be unique.

ex :1.pack1A.class

2.pack1pack2A.class

Here ex1 fully qualified name ‘ A. class’ is different from ex2

Class Name

Import MY_TEST : MyFormulaCruncher;

Local MY_TEST : MyFormulaCruncher & My_Nbr = create MY_TEST : MyFormulaCruncher();

Local number &Result;

&Result = &My _ Nbr.AddNumbers(2, 1);

Before calling any method in a class you must import the package.

Procedure for calling class methods into another peoplecode

You can create Application Packages in Application Designer. These packages contain application classes (and may contain other packages also). An application class, at its base level, is just a People Code program. However, using the Application Packages, you can create your own classes, and extend the functionality of the existing People Code classes.

Easier to debug because all the pieces are separate Easier to maintain because functionality is gathered into a single place Extensible by subclass.

Understanding Application Classes

Process for creating packages and classes application designer new definition application package insert application class

Import class Class name Class extensions Declaration of public external interface Declaration variables and methods Definition of methods

Application Classes General Structure

class MyFormulaCruncher method MyFormulaCruncher();  method AddNumbers(&a As number, &b As number) Returns number;  method AddNumbers2(); property number FirstNumber; property number SecondNumber;  property number MySum readonly; protected property number MySumProtected;end-class;

method MyFormulaCruncher end-method;

method AddNumbersLocal number &c; &c = &a + &b; MessageBox(0, "", 0, 0, "My AddNumbers result is: " | &c); Return &c;end-method;

method AddNumbers2 &MySum = &FirstNumber + &SecondNumber; &MySumProtected = &FirstNumber + &SecondNumber; MessageBox(0, "", 0, 0, "My AddNumbers2 result is: " | &MySumProtected);end-method;  t

 

Sample code

Conventional data types include number, date, string. Use them for basic computing. Object data types instantiate objects from PeopleTools class.

Conventional data types.Object data types.

Data Types

It is nothing but inheritance. We can extend the properties and methods of one class into another class using ‘extends’ key word

Example: class Fruit

method DoFruit();

property number FruitNum instance;

end-class;

class Banana extends Fruit

method DoBanana();

property number BananaNum instance;

end-class;

A subclass inherits all of the public methods and properties of the class it extends. These members can be overridden by declarations of methods and properties in the subclass.

Note. Application classes have no multiple inheritance

Class Extension

We can control the access by public , private, protected access specifiers. Public Protected Private

ex: class A

property number a1;

method number a1;

protected:

property number a2;

method number a2;

private:

property number a3;

method number a3;

Access Controls

The system never skips to the next top-level statement. Pass parameters by value. Parameter passing with object data types is by reference. Application programs use the out specifier to pass a parameter by

reference.

Note : Application class properties are always passed by value .

Definition of Methods

Passing Parameters with Object Data Types value and reference:

Parameters with object data types are always passed by referenceExample:

method myMethod(&arg as MyObjectClass);

/*method myMethod(&arg as MyObjectClass out);

Local MyObjectClass &o1 = create MyObjectClass("A");

Local MyOtherObjectClass &o2 = create MyOtherObjectClass(); 

&o2.myMethod(&o1);

Method myMethod

&arg = create MyObjectClass("B");

end-method;

note : Since the method argument is reassigned within the body of myMethod, &o1 does not point at the new instance of MyObjectClass

Definition of Methods

Passing variable by value and reference /* argument passed by reference */

method increment(&value as number out);

/* argument passed by value */:

method increment(&value as number);

class AddStuff

method DoAdd(&P1 as number, &P2 as number out);

end-class;

  method DoAdd

&X = &P1 + &P2;

&P1 = 1;

&P2 = 2;

end-method;

local AddStuff &Aref = Create AddStuff();

local number &I = 10;

local number &J = 20;

&Aref.DoAdd(&I, &J); /* changes &J but not &I */&Aref.DoAdd(10, 20); /* error - second argument not variable */

Definition of Methods

Sample code:class MyInterface method MyMethod1() abstract; method MyMethod2() Returns string abstract; method MyMethod3(); property string myproperty1 abstract readonly; property number myproperty2 abstract; property number myproperty3 abstract;end-class;method MyMethod3 /*bodyend-method;

Considerations using abstract methods:You cannot have private abstract methods.You will receive an error if you try to provide a method body for an

abstract method.The method signatures must be identical between the abstract method

definition and the method implementation in the derived.

Declaration of Abstract Methods and Properties

Defining an application class which is totally composed of abstract methods and properties is called interface it avoids the problem in multiple inheritance.

Interface MyInterface

method MyMethod1();

method MyMethod2() Returns string;

property string myproperty1 readonly;

property number myproperty2;

property number myproperty3;

end-class;

When you provide an implementation for an Interface you can also use the keyword Implements instead of Extends

Interfaces

The constructor for a class is the public method with the same name as the (short name of the) class. The statements contained in this method (if any) provide the initialization of the class.

This constructor is always executed when an object of the class is instantiated

class a

method a();

end-class;

Constructors

This section describes the naming standards for:Packages.Classes.Methods.Properties.

Packages :cc_xxx_[yyy]

classes:do not name classes to be Getxxx

Naming Standards

Import Fruit:*; Import Fruit:Banana; Import Fruit:Drinks:*;

Here any import classes having same short name we must use full name of the class for creating or initiating object to that class.

Import Declarations

A method can refer to the current object using the %This system variable. %This is an object of either the method's class or a subclass of the method's

class.

%THIS :Ex:1

class FactorialClass

method factorial(&I as number) returns number;

end-class; 

method factorial

if &I <= 1 then

return 1;

end-if;

return &I * factorial(&I - 1); /* error - factorial undefined */

return &I * %This.factorial(&I - 1); /* okay */

end-method;

Self-Reference

A method can refer to a member of its superclass by using the %Super system variable. This construction is needed only to access superclass members that are hidden by overriding members in the current class.

class BuildingAsset

method DisasterPrep();

end-class;

  method DisasterPrep

/* some body*/

end-method;

class VancouverBuilding extends BuildingAsset

method DisasterPrep();

end-class;

 method DisasterPrep

%Super.DisasterPrep(); /* call superclass method */

end-method;

local BuildingAsset &Building = Create VancouverBuilding();

&Building. DisasterPrep();

%super

class xxx

property string StringProp get set;

end-class;

get StringProp

return "string"; /* Get the value from somewhere. */

end-get; 

set StringProp

/* Do something with &NewValue. */

end-set;

Get and set methods:

A property of a superclass can be overridden by a subclassclass A

property number Anum;

property string Astring get;

property string Astring2 get;

end-class; Get Astring

return String(%This.Anum);

end-get;

Get Astring2

return String(&Anum);

end-get; class B extends A

property number Anum;

end-class;

local B &B = Create B();

&B.Anum = 2;

&MyValue = &B.Astring; /* &MyValue is "2" */

&MyValue = &B.Astring2; /* &MyValue is now "0" */

Overriding Properties

PeopleCode read-only properties are functionally similar to static variables, as long as the class that defines the properties initializes them and does not change them. The difference is that you need an instance of the class to access them.

syntax:

property number a1 read only;

&a=10;

Read-Only and read-write Properties

Application classes can contain collections. Collections of objects generally have at least the following methods and properties.

First()

Item(Index)

Next()

Count (as a property)

Collections:

Instance variables.Global variables.Overriding variables and properties.

Using Variables in Application Classes

Use the Exception class to do exception handling in your PeopleCode . This class provides a try, catch, and throw mechanism so you don't need to check after each operation for errors.

1.Exception class.

2.try.

3.catch block.

Exception class: This class contained

Exception Handling

Example for handling exxeptions

try /* Code to manipulate &MyArray here */

&MyArray = GetArrayData(&Param1, &Param2, &Param3);

catch ExceptionNull &Ex1

If &Ex1.MessageSetNumber = 2 and &Ex1.MessageNumber = 236 Then

End-if;

End-try;

Example 2:

Local Exception

&ex; Function t1(&i As integer) Returns number

Local number &res = &i / 0;

End-Function; Function t2 throw

CreateException (2, 160, "'%1' doesn't support property or method '%2'", "SomeClass", "SomeMethod");

End-Function;

try t2 ();

Local number &res = t1 (2);

Catch Exception &caugh

t MessageBox (0, "", 0, 0, "Caught exception: " | &caught.ToString());

end-try;

Application classes can be instantiated only from PeopleCode. These classes can be used anywhere you have PeopleCode, that is, in

message notification PeopleCode , Component Interface PeopleCode, record field PeopleCode, and so on.

scope of Application Classes

This section discusses some ways you can design application classes.Base data classesAbstract base classesGeneric base classesUtility classes

Designing Base Classes

Internal comments, which start with /* and end with */. Comments for methods. Comments for classes.

Method comments:

@param N.

@exception name.

@return Type.

Class Comments:

@version number.

@ author name.

Understanding Comments and Documentation

Thank you