Is AOP (Aspect Oriented Programming) concept there in SAP NetWeaver AS ?

Hi all,
Will SAP support AOP....?
If so can anyone tell how to implement AOP in Java to monitor the applications deployed in the NetWeaver Application server...
thanks
Rafi.

Hello,
To my knowledge support of AOP templates has not started yet with SAP.
AOP and Exterme Programming are things which SAP will be moving, but I dont have the dates
regards
Vivek Nidhi

Similar Messages

Aspect-Orientated Programming?

I have been looking through a few documents to try give me a better understanding of Aspect-Orientated Programming.
I was wondering if it is possible to write a class using AspectJ which could tell me details about a running Java program such as what methods are called and when.
Basically I am wondering whether it's possible to write a class using aspectJ which can capture information from another running class?
I am not looking to find out how this is done, just whether it is possible.
Thanks.

Yes, you would just create a pointcut that
encompasses all methods in A, then write whatyou
want done for that join point in your aspectI assume though that I would have to add thesepoint
cuts to the source code of class A myself? Thersis
no way to get these point cuts into class Awithout
writing into the source?Just to reiterate - things like pointcuts are part of
the aspect, not the source - (one of ) the point of
AOP is to not have to touch the source, all the logic
is contained within the aspect and injected into
the class file, not the source file.Right. You can think of servlet filters as being similar to aspects. You write the filter, but you only run it when you put it into your web.xml. It can be called before the servlet to operate on the request or, in the latest version of the servlet spec, after the servlet to operate on the response.
Your point exactly, Lee. It's not part of the source code for the class being operated on. It's a separate class, configured in a deployment descriptor.
%

Object Oriented Programming concepts

Hi Friends,
I need your help to understand the Object Oriented Programming concepts.
Please help me…
Thanks,
Fl4syed

Hi,
We can learn oops concepts very easily.Refering some books and search this concepts in some websites related to it.I think the author Robert lafore of oops is one of the best way to learn oops concepts.

BPEL and Aspect Oriented Programming ?

Is there any way to have croscutting concerns (e.g. logging, security, compensation, etc.) in BPEL processes ?
I have to write several BPEL processes with common functionality and I would like to know if this can be achieved reusing functionality, or I have to copy-and-paste common functionality in all my processes.
If I change some functionality, do I have to change all my processes ?
Any suggestion or recommendation is welcome.

You could try having some seperate BPEL processes to address some of the aspects. This will be easier with some aspects than others.
If you always invoke the default version of the aspect processes then as you modify the aspects then it will be possible to modify behaviour by redploying the aspect process and promoting it to be the default.

ALV using Object oriented programming concepts

Hi All,
I am unable to call a transaction after a hotspot click on a field.... I have used CALL METHOD w_grid->get_current_cell to get the cell info.....but this is not happening.... Can anyone plz tell me how to call a transaction on doing a hotspot click on a field?

One reason why your code is not working is i think the method you are using is Protected. ie it can't be used outside the class.
Try the following code.
In the method definition define the method as follows.
methods : HOTSPOT_CLICK
                 FOR EVENT HOTSPOT_CLICK OF CL_GUI_ALV_GRID
                 IMPORTING E_ROW_ID
                                   E_COLUMN_ID
                                   ES_ROW_NO.
The E_ROW_ID   E_COLUMN_ID   ES_ROW_NO are the parameters returnned by the event HOT-SPOT click.
Let us suppose I_MARA is your internal table using which you have displayed your ALV HRID.
Now in the method Implementation part use the following code.
METHOD HOTSPOT_CLICK.
    CLEAR : WA_MARA.
    READ TABLE I_MARA INDEX E_ROW_ID INTO WA_MARA.
    IF SY-SUBRC EQ 0.
      IF E_COLUMN_ID-FIELDNAME EQ C_MATNR.
        SET PARAMETER ID 'MAT' FIELD WA_MARA-MATNR.
        SET PARAMETER ID 'WRK' FIELD C_WERKS.
        CALL TRANSACTION 'MD04' AND SKIP FIRST SCREEN.
      ELSE.
        CALL SCREEN 0130 starting at 35 15.
      ENDIF.
    ENDIF.
ENDMETHOD.
At the call Transaction point you can call which ever Transaction you want.
And aslo please check if you have registered the event HOTSPOT.
Hope this code works.
Thanks & regards,
Y Gautham

Trying to understand the basic concept of object oriented programming.

I am trying to understand the basic concept of object oriented programming.
Object - a region of storage that define is defined by both state/behavior.
( An object is the actual thing that behavior affects.)
State - Represented by a set of variables and the values they contain.
(Is the location or movement or action that is the goal that the behavior is trying to accomplish.)
Variables- (What does this mean?)
Value - (What does this mean?)
Behavior - Represented by a set of methods and the logic they implement.
( A set of methods that is built up to tell's the how object to change it's state. )
Methods - A procedure that is executed when an object receives a message.
( A very basic comand.For example the method tells the object to move up, another method tells the method to go left. Thus making the object move up/left that combination is the behavior.)
Class - A template from which the objects are created.
( I am very confused on what classes are.)
- The definitions of the words I obtained from the "Osborne Teach Yourself Java". The () statements are how I interperate the Mechanisms (I do not know if Thats what you call them.) interact with each other. I understand my interpretation may be horribly wrong. I will incredibly appreciate all the support I may get from you.
Thank you

Object oriented programming is a replacement for the older idea of procedural programming (you can research procedural programming in google). As I understand it, in procedural programming, you have a step by step set of function calls to accomplish some task. Each function receives a data structure, manipulates it, and passes it to the next function. The problem with this is that each function preforms some action for the overall task and can't easily be reused by some other task. Its also harder to read the flow of what is happening with raw data structures flying all over the place.
In object oriented programming, an object calls a function of another object and receives back, not a data structure, but another object. Objects contain a data structure that can only be accessed by its functions. An object is not so much a sub component of a bigger task, as it is a service that any other task can use for any purpose. Also, when you pass an object to the caller, the caller can ask questions about the data structure via its functions. The developer doesnt have to know what the previous function did to the data by reading up on any documentation, or having to reverse engineer the code.
I suggest the best way of learning this is to code something like a library object.
A library object contains a collection of book objects
A book object contains a collection of chapter objects
A chapter object contains a collection of paragraph objects
A paragraph object contains a collection of sentence objects
A sentence object contains a collection of word objects.
Add functions to each object to provide a service
Example: A library object should have a:
public void addBook(Book book)
public Book getBook(String title)
public boolean isBookInLibrary(String title)
The key is to add functions to provide a service to anyone who uses your object(s)
For example, what functions (service) should a paragraph object provide?
It shouldn't provide a function that tells how many words there are in a sentence. That function belongs to a sentence object.
Lets say you want to add a new chapter to a book. The task is easy to read
if you write your objects well:
Sentence sentence1=new Sentence("It was a dark and stormy night");
Sentence sentence2=new Sentence("Suddenly, a shot ran out");
Paragraph paragraph=new Paragraph();
paragraph.addSentence(sentence1);
paragraph.addSentence(sentence2);
Paragraphs paragraphs=new Paragraphs();
paragraphs.addParagraph(paragraph);
Library library= new Library();
library.getBook("My Novel").addChapter("Chapter 1",paragraphs).
Now, lets say you want to have a word count for the entire book.
The book should ask each chapter how many words it contains.
Each chapter should ask its paragraphs, each paragraph should ask
its sentences. The total of words should ripple up and be tallied at each
stage until it reaches the book. The book can then report the total.
Only the sentence object actually counts words. The other objects just tallies the counts.
Now, where would you assign a librarian? What object(s) and functions would you provide?
If written well, the project is easily extensible.

Object oriented programming aspects in Oracle

Dear All,
Can you one explain me the aspects of Object Oriented Programming in Oracle. How to use oops concepts in Oracle Procedures, functions, packages, etc.
Thanks,
Moorthy.GS

Oracle 9i introduces support for inheritance, method overriding and dynamic method dispatch (or "dynamic binding", or "virtual").
A method call is dispatched to the nearest implementation, working back up the inheritance hierarchy from the current or specified type.
See, for example, how we can implement the Template Design Pattern in PL/SQL, using inheritance, method overriding and dynamic method dispatch:
http://www.quest-pipelines.com/pipelines/plsql/tips06.htm#OCTOBER
Oracle 11g introduces support for "super" object-oriented keyword. One attempt to do this in PLSQL 9i/10g:
Calling the Parent Object's Version of an Overridden Method
http://www.quest-pipelines.com/pipelines/plsql/tips03.htm#JUNE
I expect some OO improvements in the future (in Oracle 12oo ...):
1. References between transient objects (instances of objects types) and (then) garbage collector
2. Generic classes (templates, generics) like in Eiffel, C++, Java 5 (PL/SQL was modeled after ADA 83, and ADA 83 has generic packages)
3. Multiple inheritance like in Eiffel (inner classes like in Java - no, please)
4. Design By Contract like in Eiffel (C++ / Java 1.4 assert is not enough)
Design by contract (DBC) is a method whose author is Bertrand Mayer, also maker of OOPL language Eiffel
(Eiffel was designed in 1985, commercialy released in 1986, ISO-standardized in 2006).
Simplified, DBC is based on principle that in each routine (procedure or function) with standard code,
two additional parts – PRECONDITION and POSTCONDITION - need to be asserted.
An additional assertion in class is called INVARIANT.
Contract is based on routine's putting up an obligation to caller (to some other routine)
to satisfy conditions of precondition and conditions of invariant, and hers (called routine's) obligation
to satisfy conditions of postcondition and conditions of invariant.
The object oriented Eiffel programming language was created to implement DBC.
For now, other OO (object-oriented) languages don’t support directly the ideas behind DBC.
However, precondition and postcondition are applicable to many programming languages, both OO and not OO.
Invariants are applicable only in OOPL.
This is my attempt to use DBC methodology (including invariants) in Oracle PL/SQL.
Eiffel class interface (not like Java interface, but more like PL/SQL package specification)
from Bertrand Meyer's book "Object oriented software construction", second edition (OOSC2), 1997, page 390-391:
class interface STACK [G]
creation make
feature -- Initialization
make (n: INTEGER) is -- Alocate stack for a maximum of n elements
    require
      non_negative_capacity: n >= 0
    ensure
      capacity_set: capacity = n
    end
feature -- Access
capacity: INTEGER -- Maximum number of stack elements
count: INTEGER -- Number of stack elements
item: G is -– Top element
    require
      not_empty: not empty
    end
feature -- Status report
empty: BOOLEAN is –- Is stack empty?
    ensure
      empty_definition: Result = (count = 0)
    end
full: BOOLEAN is –- Is stack full?
    ensure
      full_definition: Result = (count = capacity)
    end
feature -- Element change
put (x: G) is –- Add x on top
    require
      not_full: not full
    ensure
      not_empty: not empty
      added_to_top: item = x
      one_more_item: count = old count + 1
    end
remove is -– Remove top element
    require
      not_empty: not empty
    ensure
      not_full: not full
      one_fewer: count = old count - 1
    end
invariant
count_non_negative: 0 <= count
count_bounded: count <= capacity
empty_if_no_elements: empty = (count = 0)
end -– class interface STACK
-- PL/SQL "equivalent":
-- Stack implementation - TABLE of INTEGER.
-- Eiffel has generic classes (like C++ templates and better than Java generics).
-- PL/SQL (now) has not generic classes or generic packages.
CREATE OR REPLACE TYPE array_t AS TABLE OF INTEGER
-- utility package:
CREATE OR REPLACE PACKAGE dbc AS
-- 0 = no check
-- 1 = check preconditions
-- 2 = check preconditions + postconditions
-- 3 = check preconditions + postconditions + invariants
c_no_check                  CONSTANT INTEGER := 0;
c_check_preconditions       CONSTANT INTEGER := 1;
c_check_pre_postconditions CONSTANT INTEGER := 2;
c_check_pre_post_invariants CONSTANT INTEGER := 3;
FUNCTION check_preconditions       RETURN BOOLEAN;
FUNCTION check_pre_postconditions RETURN BOOLEAN;
FUNCTION check_pre_post_invariants RETURN BOOLEAN;
PROCEDURE set_level (p_level INTEGER);
PROCEDURE display_error (p_error VARCHAR2);
END;
CREATE OR REPLACE PACKAGE BODY dbc AS
m_level INTEGER := c_no_check;
FUNCTION check_preconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_preconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_postconditions RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_postconditions THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
FUNCTION check_pre_post_invariants RETURN BOOLEAN IS
BEGIN
    IF m_level >= c_check_pre_post_invariants THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
PROCEDURE set_level (p_level INTEGER) IS
BEGIN
    IF p_level NOT IN
      (c_no_check, c_check_preconditions, c_check_pre_postconditions, c_check_pre_post_invariants)
    THEN
      RAISE_APPLICATION_ERROR (-20000, 'Wrong checking level');
    END IF;
    m_level := p_level;
END;
PROCEDURE display_error (p_error VARCHAR2) IS
BEGIN
    RAISE_APPLICATION_ERROR (-20000, 'ERROR in method ' || p_error);
END;
END;
CREATE OR REPLACE TYPE stack AS OBJECT (
-- Maximum number of stack elements
capacity INTEGER,
-- Number of stack elements
el_count INTEGER,
-- Stack implementation
stack_implementation array_t,
-- Alocate stack for a maximum of n elements
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT,
-- Top element
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER,
-- Is stack empty?
MEMBER FUNCTION empty RETURN BOOLEAN,
-- Is stack full?
MEMBER FUNCTION full RETURN BOOLEAN,
-- Add x on top
MEMBER PROCEDURE put (x INTEGER),
-- Remove top element
MEMBER PROCEDURE remove,
-- INVARIANTS
-- Note:
-- If subprogram is declared in an object type body (in PL/SQL 8i/9i/10g)
-- it must be defined in the object type specification too.
MEMBER FUNCTION count_non_negative RETURN BOOLEAN,
MEMBER FUNCTION count_bounded RETURN BOOLEAN,
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN,
MEMBER PROCEDURE check_invariants
) NOT FINAL;
CREATE OR REPLACE TYPE BODY stack AS
CONSTRUCTOR FUNCTION stack (n INTEGER) RETURN SELF AS RESULT IS
BEGIN
    IF dbc.check_preconditions AND n < 0 THEN
      dbc.display_error ('stack - PRE');
    END IF;
    check_invariants;
    capacity := n;
    stack_implementation := array_t();
    stack_implementation.EXTEND (n);
    IF dbc.check_pre_postconditions AND capacity <> n THEN
      dbc.display_error ('stack - POST');
    END IF;
    check_invariants;
END;
MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER IS
BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('item - PRE');
    END IF;
    check_invariants;
    RETURN stack_implementation(el_count);
END;
MEMBER FUNCTION empty RETURN BOOLEAN IS
BEGIN
    IF el_count = 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION full RETURN BOOLEAN IS
BEGIN
    IF el_count = capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE put (x INTEGER) IS
BEGIN
    IF dbc.check_preconditions AND full THEN
      dbc.display_error ('put - PRE');
    END IF;
    check_invariants;
    el_count := el_count + 1;
    stack_implementation(el_count) := x;
    -- PL/SQL has not Eiffel's OLD
    -- one_more_item: count = old count + 1
    IF dbc.check_pre_postconditions AND (empty OR item <> x) THEN
      dbc.display_error ('put - POST');
    END IF;
    check_invariants;
END;
MEMBER PROCEDURE remove IS BEGIN
    IF dbc.check_preconditions AND empty THEN
      dbc.display_error ('remove - PRE');
    END IF;
    check_invariants;
    el_count := el_count - 1;
    -- PL/SQL has not Eiffel's OLD
    -- one_fewer: count = old count - 1
    IF dbc.check_pre_postconditions AND full THEN
      dbc.display_error ('remove - POST');
    END IF;
    check_invariants;
END;
-- INVARIANTS
MEMBER FUNCTION count_non_negative RETURN BOOLEAN IS
BEGIN
    IF el_count >= 0 THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION count_bounded RETURN BOOLEAN IS
BEGIN
    IF el_count <= capacity THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER FUNCTION empty_if_no_elements RETURN BOOLEAN IS
BEGIN
    IF empty AND (el_count = 0)
       OR
       NOT empty AND (el_count <> 0)
    THEN
      RETURN TRUE;
    ELSE
      RETURN FALSE;
    END IF;
END;
MEMBER PROCEDURE check_invariants IS
BEGIN
    IF NOT dbc.check_pre_post_invariants THEN
      RETURN; -- without checking invariants
    END IF;
    IF NOT count_non_negative THEN
      dbc.display_error ('INVARIANT count_non_negative');
    END IF;
    IF NOT count_bounded THEN
      dbc.display_error ('INVARIANT count_bounded');
    END IF;
    IF NOT empty_if_no_elements THEN
      dbc.display_error ('INVARIANT empty_if_no_elements');
    END IF;
END;
END; -- class body STACK
/Regards,
Zlatko Sirotic

Concept of object oriented programming

does anyone have notes on concepts of object oriented programming language (Encapsulation,polymorphism,messages,class,inheritance and all that) i tried to find them but i only got definitions for them but i want advantages and disadvantages of concepts also plz can anyone help me

You want the advantages/disadvantages.. hard to find... i got some notes on OO concepts.. u want? Please send me a email to [email protected].. will post it on geocities with the link once u send me the email

Java is pure object oriented programing language or not why?

please clear
java is pure object oriented programing language or not why?

And there is some concepts of object orientation that
Java not implements like: Operator
Overloading and Multiple Heritage. But, i think
that we can live without those features.
And the sucess of Java is a proof of this.I don't believe that operator overloading and multiple inheritance are required aspects of object programming.

Java is a Partially Object-Oriented Programming (True/False)

Hi everybody,
Many of them saying that Java is not purely Object-Oriented Programming.
I am very much confusing on that, so please help me to confirm that "Java is a Partially Object-Oriented Programming Language".

JAVA_NV wrote:
gopivista wrote:
Hi everybody,
Many of them saying that Java is not purely Object-Oriented Programming.
I am very much confusing on that, so please help me to confirm that "Java is a Partially Object-Oriented Programming Language".Java is not purely Object-Oriented Programming,for this two reasons are there
one is we cant create Objects to the primitive data types and there is no multiple Inheritance concept .While there are many definitions of "purely object oriented," and no on widely accepted standard, I've never heard one that requires multiple inheritance. That would NOT be a reason why Java is not fully OO.

Object-oriented programming: state and behaivor

First of all, sorry for my level english.
In Object-Oriented programming, should an object save always some state?
What about session stateless bean service? What is the sense?
These objects have only behaivour and not state.
Perhaps, the sense is that you can send a message to this object, in oposite of a static methods in utility class?
Thanks and regards.

I suppose you could argue that if it doesn't have any state, then it's not really an "object" in the OOP sense, but who cares, really.
Personally, I use state and behavior as a way to help clarify the responsibilities of various classes in the system, and if I see a codebase with a lot of objects with state but no behavior or behavior but no state, then it's a a red flag that it's a messy, poorly-thought-out design (and it usually turns out to be exactly that). The whole point of OOP (IMHO) is encapsulation, and bundling state and behavior together makes things encapsulated (you can prove that state changes only in certain areas in certain circumstances). Encapsulation makes for more easily maintainable code.
It's easy to spot the blue squares in a Mondrian. It's difficult to spot the blue bits in a Pollock. The former is well-encapsulated OOP and the latter is poorly-encapsulated spaghetti code.
That said, it's not the end of the world if you have a static utility class here and there.

Object oriented programming in LabVIEW

Please send this message to everybody who has an opinion about this.
Please try to keep it short, but if you can't control yourselves, let
it all out!
I would like to have your opinions about the nature of Labview and it's
ability to support object oriented programming.
I have a couple of questions to fire the discussion.
1- Do you think that LV was built to support OO Programming?
2- Is OO the only way we have to support large applications, or is it
feasible to support it with a good dataflow architecture including all
the flowcharts and all the data definitions?
3- Is LV going to stay "dataflow" or is it going to become OO?
4- What would be the great benefits of turning LV to OO that we don't
already have w
ith the dataflow approach?
5- My opinion is that trying to implement OO in LabVIEW, is like trying
to
Thank you all for your time.
Sent via Deja.com
http://www.deja.com/

> 1- Do you think that LV was built to support OO Programming?
LV was initially designed in 1983. OOP existed at that point,
but LV wasn't designed to be OO. It was designed to allow
engineers and researchers a simple language appropriate
for controlling their research labs from a computer.
> 2- Is OO the only way we have to support large applications, or is it
> feasible to support it with a good dataflow architecture including all
> the flowcharts and all the data definitions?
OO lends itself to large projects because it provides
abstraction, encapsulation, and organizes code into
modules that can more easily be implemented independent
of one another since they can be specified in finer
detail. Also, the compilers help to enforce the
specifications providing they can be encoded in the
interface between objects.
These OO principles were already a part of big projects
long before there were OO languages. It was just that
the language didn't necessarily have features which
supported it. Similarly, they can be a part of big
projects today despite the language being used.
LV 2 style globals, which as the name suggests were
in use long ago, encapsulate data with an interface.
They disallow arbitrary access to the data and can be
used to enforce correct access. With other functions
layered on top, you get a nice interface to stored data.
Functions and structs/clusters abstract away details.
Building a subVI that does an FFT means that for 99%
of the uses, you don't need any more information except
that this block performs an abstract mathematical function,
an FFT. The implementation can be completely changed
to speed it up or make it more accurate and your code
isn't affected. Its abstract definition still holds, so
your code still works.
There are other things that OO languages bring to the
table that LV, and GOOP don't yet offer. In my opinion,
a few more OO features can be added to LV to allow for
even larger projects in the future provided they are used
well.
Earlier posts pointed out that C++ doesn't guarantee that
a project will succeed. OO features are just another tool,
and the tool can be misused leading to a failed project.
This is true to LV, C, C++, and all other engineering tools.
The key is using the tools at hand to best solve the
problems we face. Not glorifying or blaming the tools for
the state of the project.
> 3- Is LV going to stay "dataflow" or is it going to become OO?
LV is dataflow to the core. The definition of what data
is flowing may be expanded, but it will still be data
flowing down wires from one node to another that accounts
for how the program executes.
One of the limitations of the current GOOP is that all
objects are dealt with by a reference. By adding
language features, objects could be made to flow down
the wire, just like strings and arrays, meaning that
branching a wire doesn't lead to side-effects,
and there is no need to dispose objects.
> 4- What would be the great benefits of turning LV to OO that we don't
> already have with the dataflow approach?
Remember when LV didn't have typedefs? It was easy for
a cluster datatype to change once a project was underway.
That usually led to lots of edits on other panels to get
them back in synch. Without the unbundle by name, you
then went through the diagrams fixing all of the bundlers
and unbundlers to have the right number of terminals.
Changing the order of the cluster was even worse since
the diagrams may not bread, they might just access the
wrong field instead.
In many respects, an object is just another step along the
same path. An object is a typedef that can have code
associated with it for access -- maybe like Array and
Cluster Tools. Some of the typedef contents might be
publicly accessable, like now, while other elements are
hidden, only available to the implementation of the
typedef. That would force the user to use your functions
to manipulate things rather than hacking away at the
typedef contents. As an example, a LV string is really
just a cluster of size and characters. Since the diagram
can only modify the string using the string functions, you
never get the size and characters out of synch. That is
until you take it into LV generated code, a DLL or CIN
where you have access to the inner fields.
A related problem is that current typedefs are transparent
to built-in LV functions. If your typedef is just some
numbers, LV will be happy to perform arithmetic on your
typedef. Maybe this is what you want, but if this doesn't
make sense on your typedef, then your left with adding a
Boolean or a string so that the arithmetic isn't allowed.
Ideally, you would be able to state that = makes sense, >
and < don't, + and - only operates on the first numeric, and
* is something that you implement yourself. There would be
some safeguards so that the user of your typedef, which
includes you, wouldn't accidentally mangle the typedef
contents.
These may not seem like much at first, but they allow for
much more abstraction and better encapsulation. Finally,
there is a technique called inheritance that allows for
similar objects to be acted on by common code in one
location, and by specific code in another location depending
on which type of object is actually there at runtime.
This of usually done today by switching out on some inner
tag and dealing with each type in its own diagram. This
works fine until projects get large and teams get large.
Inheritance is a different way of implementing the exact
same thing that usually works much better for bigger teams
and bigger projects.
> 5- My opinion is that trying to implement OO in LabVIEW, is like trying
> to
Is this a fill-in-the blank question? It is difficult today
because the LV language doesn't yet support OO very well.
Early C++ was implemented on top of C using just a bunch
of macros and the preprocessor to mangle the C++ back into
C so that it could be compiled and run. Debugging was
done on practically unreadable text that vaguely resembled
your original code. By comparison, GOOP actually looks
pretty good. It is written entirely on top of the current
LV language and makes clever use of things like datalog
refnums to make strict types.
Over time I think GOOP will mature, and like typedefs,
some users will come to rely on it in a big way.
Other users will hopefully not even notice that anything
changed. If their project grows in complexity and they
need another tool to manage things, it will be just
another feature that helps them to get useful things done.
Greg McKaskle

Object oriented programming on PXI-System

Greetings,
i've developed some object-oriented LV classes, wich i've succesfully tested on my desktop pc. The next step would have been to test them on a PXI-controller. However, the LV 8.20 methods of object oriented programming seam to be incompatible to PXI-systems.
All i'm getting is an broken arrow with an error message like that
HardwareIOAnalog.lv.class:setTimingNP.vi
Frontpanel-Anschluss 'HardwareIOAnalog in': Der Typ wird für das aktuelle Ziel nicht unterstützt (means: Type not supported by current target)
Does that mean that object-oriented design is not supported in general by PXI, or is it depending on the type of the PXI-System. Is there an easy way around, or do i have to re-program all my classes to conventional (Sub)VIs?
Help appriciated! ;-)
Regards,
Bennet Gedan
Student (Electrical Engineering/Mechatronics)
Darmstadt University of Technology
Bennet Gedan
Student (Electrical Engineering / Mechatronics)
Darmstadt University of Technology

Okay, thanks. Meanwhile I reprogramed the whole thing and set OOP aside (at least on the PXI-Target). It's a pity to loose some advantages of OOP, but it brougth me some interesting new programing techniques i could transfer to non OOP stuff.
Regards,
Bennet Gedan
Student (Electrical Engineering / Mechatronics)
Darmstadt University of Technology

Object oriented exception concept -

Hi all,
I'm trying to get familiar with the object oriented exception concept, but there's one point which I did not understand so far:
I created an exception class inheriting from class 'CX_DYNAMIC_CHECK'. In order to store additional information, I added some additional attributes to my class that should be filled when the exception is raised.
So I tried to add additional import parameters to the constructor and to fill the additional attributes within the constructor, but I'm not able to change the constructor at all, i.e. I can't add additional import parameters nor am I able to change the source code of the constructor.
Can you give me any hint how to deal with additional attributes?
Best regards,
Markus

In order to pass more values / parameters in the CONSTRUCTOR, you need to create them as the Attributes of the class. As soon as you create it as attribute, it would be available as the signature of the CONSTRUCTOR. E.g if you add V_MESSAGE as the attribute, system would create a importing signature V_MESSAGE of CONSTRUCTOR and also add the code to populate the attribute V_MESSAGE from importing parameter V_MESSAGE.
method CONSTRUCTOR.
CALL METHOD SUPER->CONSTRUCTOR
EXPORTING
TEXTID = TEXTID
PREVIOUS = PREVIOUS
me->IV_MESSAGE = IV_MESSAGE . " <<
endmethod.
You can use this to pass the value while Raising the Exception:
RAISE EXCEPTION TYPE ZCX_TEST_NP EXPORTING
V_MESSAGE = 'This is test'.
When you catch it, you can actually use the attribute to access the value:
data: o_Exc type ref to zcx_test_np.
catch zcx_test_np into o_exc.
write: / 'Exception', o_Exc->v_message.
Regards,
Naimesh Patel

Table Control in Object oriented programing

Hi ,
All of our programs are converted into OO Programing, i have a requirement that can we have an alternative for Table Control in Object oriented programing ?
can we have any base class for Table Control to display the data in the grid ?
For Ex: we can place a ALVA Tree on the container , For this the base class is CL_GUI_ALVA_TREE, like the same way can we have any alternative,
If i am not wrong is it possible by ALV grid Control.. can any body help me the out
of this confusion.
Thansk In Advance.
Regards
Nag

Thanks for this, it is very help full. If you don't mind is there any demo program which is already given by SAP, or if you have please send me the code so that
i can start looking on it .
thanks In Advance.
Regards
Nag

Is AOP (Aspect Oriented Programming) concept there in SAP NetWeaver AS ?

Similar Messages

Maybe you are looking for