About The Repository Design Approach

Hi All,
I am working for a project on OBIEE in which this tool is used for Ad Hoc Reporting. I need to create a repository that should be generic one means i need to create a repository that i need to handover to the client.
This repository should be flexible enough so that they can create various reports based on their requirement .
I am not clear, is it possible to create a repository that will be a generic one? Can this be possible?
Can their is any approach to design that will be flexible and generic?

I think you can, because you can build in a lot of intelligence in the business and model layer.
My approach is always to make it first as generic as possible, and once I am ready with that I am going to look how to make it more flexible, so the end users can work better with answers.
However, have a look on:
http://www.oracle.com/technology/obe/obe_bi/bi_ee_1013/bi_admin/biadmin.html
Here you can see how to make a repostitory, first they make the model (generic)
and after that they add columns like "profit month ago" so the end users have more options in answers (flexible)
I think the business model and mapping is very powerfull, but you must know how to use it ;)
So building a repository is not hard, but the challenge is in building a good repository!
succes!

Similar Messages

Some question about the query designer

hello, dear all,
I am a new comer of here, and I am intersting in BI, but I have no basic knowledge about it.
so I just want someone could give me some advice about it.
our boss need I do the developer about the query designer, I just have searched in this forum. but nothing founded for I am a new comer here,
I heard there are some training document of the query designer, could someone give me the URL, thanks.

Hi,
Query desinger is used to develop a Query, Query can be created on following data targets
-Info Cube
-DSO
Virtual data target
-MultiCube
-Infoset
-Multiprovider
We have 5 section in query designer
- Infoprovider : where we select the data target , on which report to be created
-Filter : to restrict value at infoprovider level ( if you want data for year 2008, for example)
-Free Characterstic : this allow you to drill down
-Columns : char/keyfigs to be display in columns can be added here
Row: key/char to be display in Rows can be added here
gv me ur mailid i will let u have Bex manual,
I would suggest , if you have any IDES ( training ) system , where you can log in and then go to RRMX,
and try to create new query and add any data target ( which is already created ) and then drag and drop the char/key fig to the required section ,
save it and execute it .....
if you play arround and see the output , that would help u to understand how to work with query designer.
Hope this helps
Sukhi
Edited by: Sukhvidner Singh on Nov 4, 2009 5:36 PM

The one thing that bugs me about the iMac design is.....

The one thing that bugs me about the imac is..... the sleep mode led.
Was it beyond the ken of the designers to make it apple shaped?
Now - call me recklessy stupid, but.....
Having seen how easily the front cover can be detatched, how much of a dolt would i be to try and fit a foil blank apple, or apple shaped hole blank inside the casing to rectify this inconsequential but nagging annoyance?
You see, recently making the leap from pc land, I am left with hours of empty time on my hands.
Time that would usually be profitably taken up by debugging, reinstalling, restarting, recovering, rebooting and waiting for all of the above, and generally working around the 'beige box of nightmares'.
Or should I just stop proctastinating and finish off the latest chapter of my upcoming video project, to be previewed 4 weeks tonight?

Whip out your hacksaw and have at it, realizing you are voiding any warranty that you had.
Good luck.

The Question about the LiveCycle Designer

I have one sheet that contains three Loop tables.
because the data of table is more than the number of rows in sheet,
for example,I have ten tools and ten spare parts want to prepare.
It needs to pagination.how can I do it?
Work Sheet
tools
spare parts
materials
The position of boldface in sheet is fixed.
Who can help me?
Thanks!!!!!!

Who Can Help Me?

The new design of X240

I am an owner of the X230 and use it professionally as I am a programmer. I immediately fell in love with lenovos keypad and the trackpoint. From the first moment on I disabled the normal touchpad and would only use the trackpoint. As someone who uses his notebook several hours a day I have to say there is nothing better than the Trackpoint. The ergonomic positioning lets me use the trackpoint while pressing the mousebuttons on the keypad very efficiently.
I am a little bit disappointed about the new design of the X240, since it does not have dedicated buttons but only a touchpad. I know this issue does not seem very important but I thought I give some feedback. I love it that the mousebuttons are actual buttons and how they behave when pressed. I have used many other notebooks and never liked the way how they solved this issue, but with the x230 I soon realized what a great job lenovo did.
To summarize:
I'd like to see the return of the actual mousebuttons in future models.
Another really great thing would be the option to get one completely without the touchpad, since most of the people I know do not even use it.
Finally I have to say lenovo does produce great product, especially comparing to its competition.
Please tell me your opinion on the matter.

nurfed wrote:
I am an owner of the X230 and use it professionally as I am a programmer. .
You probably want to use F keys and End key, won't you ? http://forums.lenovo.com/t5/X-Series-ThinkPad-Laptops/X240-End-Insert-Fn-key-woes/td-p/1330763

Technical questions about the BO repository

Hi to all,
I order to understand how BO (talking about BO 3.0) act internally, I need to know the following questions:
- What information is held in the repository database? Content or just metadata?
- What is held in the properties blob of the bo_repos.cms_infoobjects6 table?
- What is held in the data blob of the bo_repos.cms_relations6 table?
- Is there any possibility to change directly the UID of an object (eg: a universe) in the database directly? This action could be helpful to work with versions..
Is there any technical documentation?
Many thanks,
Bea

Hi Bea,
I tested your case in my environment. After changing the definition of a key figure in my universe (this should be your development version), I renamed it (used the name of a universe on which I already had some reports running on) and tried to export it in the BOBJ repository. The designer prompted me to select if I want to copy or move my universe. I choose to create a copy of my universe and on the next step I was asked if I want to overwrite the universe with the same name (in your case this should be your production version). I confirmed overwriting the universe and started then my WebI reports (production reports) in the InfoView. Everything worked fine and the modification was visible.
Please note that if during the development phase you remove/rename/change the visibility of universe objects (classes, dimensions, key figures), which are used in your existing WebI reports, then you will indeed may have problems. Even if you delete a class or object and add later a new one with the same name, there's no garantee that a WebI report which was using this object will work.
Still if you just modify or add objects during the development or if you remove first the objects, which you want to delete, from your reports, then you should not have a problem with the approach we are discussing here.
Regards,
Stratos

What do people think about the different Generic Java approaches?

I have seen a lot of different approaches for Generic Java, and when people find problems with each approach the normal response has been: the other approach is worse with such and such a problem, do you have a better way?
The different approaches I have seen are: (in no particular order)
Please correct me if I am wrong and add other approaches if they are worthy of mention.
1) PolyJ - by MIT
This is a completely different approach than the others, that introduces a new where clause for bounding the types, and involves changing java byte codes in order to meet it's goals.
Main comments were not a java way of doing things and far too greater risk making such big changes.
2) Pizza - by Odersky & Wadler
This aims at extending java in more ways than just adding Generics. The generic part of this was replaced by GJ, but with Pizza's ability to use primitives as generic types removed, and much bigger changes allowing GJ to interface with java.
Main comments were that Pizza doesn't work well with java, and many things in Pizza were done in parallel with java, hence were no longer applicable.
3) GJ - by Bracha, Odersky, Stoutamire & Wadler
This creates classes with erased types and bridging methods, and inserts casts when required when going back to normal java code.
Main comments are that type dependent operations such as new, instanceof, casting etc can't be done with parametric types, also it is not a very intuitive approach and it is difficult to work out what code should do.
4) Runtime Generic Information - by Natali & Viroli
Each instance holds information about its Runtime Type.
Main comments from people were that this consumes way too much memory as each instance holds extra information about its type, and the performance would be bad due to checking Type information at runtime that would have been known at compile.
5) NextGen - by Cartwright & Steele
For each parameterized class an abstract base class with types erased is made and then for each new type a lightweight wrapper class and interface are created re-using code from the base class to keep the code small.
Main comments from people were that this approach isn't as backwards compatible as GJ due to replacing the legacy classes with abstract base classes which can't be instantiated.
6) .NET common runtime - by Kennedy & Syme
This was written for adding Generics to C#, however the spec is also targeted at other languages such as VB.
Main comments from people were that this approach isn't java, hence it is not subject to the restrictions of changing the JVM like java is.
7) Fully Generated Generic Classes - by Agesen, Freund & Mitchell
For each new type a new class is generated by a custom class loader, with all the code duplicated for each different type.
Main comments from people were that the generated code size gets too big, and that it is lacking a base class for integration with legacy code.
8) JSR-14 - by Sun
This is meant to come up with a solution Generic Solution to be used in java. Currently it is heavily based on GJ and suffering from all the same problems as GJ, along with the fact that it is constantly undergoing change and so no one knows what to expect.
See this forum for comments about it.
As if we didn't have enough approaches already, here is yet another one that hopefully has all of the benefits, and none of the problems of the other approaches. It uses information learnt while experimenting with the other approaches. Now when people ask me if I think I have a better approach, I will have somewhere to point them to.
(I will be happy to answer questions concerning this approach).
9) Approach #x - by Phillips
At compile time 1 type is made per generic type with the same name.
e.g.class HashSet<TypeA> extends AbstractSet<TypeA> implements Cloneable, Serializable will be translated to a type: class HashSet extends AbstractSet implements Cloneable, SerializableAn instance of the class using Object as TypeA can now be created in 2 different ways.
e.g.Set a = new HashSet();
Set<Object> b = new HashSet<Object>();
//a.getClass().equals(b.getClass()) is trueThis means that legacy class files don't even need to be re-compiled in order to work with the new classes. This approach is completely backwards compatible.
Inside each type that was created from a generic type there is also some synthetic information.
Information about each of the bounding types is stored in a synthetic field.
Note that each bounding type may be bounded by a class and any number of interfaces, hence a ';' is used to separate bounding types. If there is no class Object is implied.
e.g.class MyClass<TypeA extends Button implements Comparable, Runnable; TypeB> will be translated to a type: class MyClass {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Button.class, Comparable.class, Runnable.class}, {Object.class}};This information is used by a Custom Class Loader before generating a new class in order to ensure that the generic types are bounded correctly. It also gets used to establish if this class can be returned instead of a generated class (occurs when the generic types are the same as the bounding types, like for new HashSet<Object> above).
There is another synthetic field of type byte[] that stores bytes in order for the Custom Class Loader to generate the new Type.
There are also static methods corresponding to each method that contain the implementation for each method. These methods take parameters as required to gain access to fields, contructors, other methods, the calling object, the calling object class etc. Fields are passed to get and set values in the calling object. Constructors are passed to create new instances of the calling object. Other methods are passed when super methods are called from within the class. The calling object is almost always passed for non static methods, in order to do things with it. The class is passed when things like instanceof the generated type need to be done.
Also in this class are any non private methods that were there before, using the Base Bounded Types, in order that the class can be used exactly as it was before Generics.
Notes: the time consuming reflection stuff is only done once per class (not per instance) and stored in static fields. The other reflection stuff getting done is very quick in JDK1.4.1 (some earlier JDKs the same can not be said).
Also these static methods can call each other in many circumstances (for example when the method getting called is private, final or static).
As well as the ClassLoader and other classes required by it there is a Reflection class. This class is used to do things that are known to be safe (assuming the compiler generated the classes correctly) without throwing any exceptions.
Here is a cut down version of the Reflection class: public final class Reflection {
public static final Field getDeclaredField(Class aClass, String aName) {
    try {
      Field field = aClass.getDeclaredField(aName);
      field.setAccessible(true);
      return field;
    catch (Exception ex) {
      throw new Error(ex);
public static final Object get(Field aField, Object anObject) {
    try {
      return aField.get(anObject);
    catch (Exception ex) {
      throw new Error(ex);
public static final void set(Field aField, Object anObject, Object aValue) {
    try {
      aField.set(anObject, aValue);
    catch (Exception ex) {
      throw new Error(ex);
public static final int getInt(Field aField, Object anObject) {
    try {
      return aField.getInt(anObject);
    catch (Exception ex) {
      throw new Error(ex);
public static final void setInt(Field aField, Object anObject, int aValue) {
    try {
      aField.setInt(anObject, aValue);
    catch (Exception ex) {
      throw new Error(ex);
}Last but not least, at Runtime one very lightweight wrapper class per type is created as required by the custom class loader. Basically the class loader uses the Generic Bytes as the template replacing the erased types with the new types. This can be even faster than loading a normal class file from disk, and creating it.
Each of these classes has any non private methods that were there before, making calls to the generating class to perform their work. The reason they don't have any real code themselves is because that would lead to code bloat, however for very small methods they can keep their code inside their wrapper without effecting functionality.
My final example assumes the following class name mangling convention:
* A<component type> - Array
* b - byte
* c - char
* C<class name length><class name> - Class
* d - double
* f - float
* i - int
* l - long
* z - boolean
Final Example: (very cut down version of Vector)public class Vector<TypeA> extends AbstractList<TypeA> implements RandomAccess, Cloneable, Serializable {
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
public Vector<TypeA>(int anInitialCapacity, int aCapacityIncrement) {
    if (anInitialCapacity < 0) {
      throw new IllegalArgumentException("Illegal Capacity: " + anInitialCapacity);
    elementData = new Object[initialCapacity];
    capacityIncrement = capacityIncrement;
public synchronized void setElementAt(TypeA anObject, int anIndex) {
    if (anIndex >= elementCount) {
      throw new ArrayIndexOutOfBoundsException(anIndex + " >= " + elementCount);
    elementData[anIndex] = anObject;
}would get translated as:public class Vector extends AbstractList implements RandomAccess, Cloneable, Serializable {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
private static final Field $0 = Reflection.getDeclaredField(Vector.class, "elementData"),
                             $1 = Reflection.getDeclaredField(Vector.class, "elementCount"),
                             $2 = Reflection.getDeclaredField(Vector.class, "capacityIncrement");
static void $3(int _0, Field _1, Object _2, Field _3, int _4) {
    if (_0 < 0) {
      throw new IllegalArgumentException("Illegal Capacity: " + _0);
    Reflection.set(_1, _2, new Object[_0]);
    Reflection.setInt(_3, _2, _4);
static void $4(int _0, Field _1, Object _2, Field _3, Object _4) {
    if (_0 >= Reflection.getInt(_1, _2)) {
      throw new ArrayIndexOutOfBoundsException(_0 + " >= " + Reflection.getInt(_1, _2));
    ((Object[])Reflection.get(_3, _2))[_0] = _4;
public Vector(int anInitialCapacity, int aCapacityIncrement) {
    $3(anInitialCapacity, $0, this, $2, aCapacityIncrement);
public synchronized void setElementAt(Object anObject, int anIndex) {
    $4(anIndex, $1, this, $0, anObject);
} and new Vector<String> would get generated as:public class Vector$$C16java_lang_String extends AbstractList$$C16java_lang_String implements RandomAccess, Cloneable, Serializable {
protected Object[] elementData;
protected int elementCount;
protected int capacityIncrement;
private static final Field $0 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "elementData"),
                             $1 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "elementCount"),
                             $2 = Reflection.getDeclaredField(Vector$$C16java_lang_String.class, "capacityIncrement");
public Vector$$C16java_lang_String(int anInitialCapacity, int aCapacityIncrement) {
    Vector.$3(anInitialCapacity, $0, this, $2, aCapacityIncrement);
public synchronized void setElementAt(String anObject, int anIndex) {
    Vector.$4(anIndex, $1, this, $0, anObject);
}Comparisons with other approaches:
Compared with PolyJ this is a very java way of doing things, and further more it requires no changes to the JVM or the byte codes.
Compared with Pizza this works very well with java and has been designed using the latest java technologies.
Compared with GJ all type dependent operations can be done, and it is very intuitive, code does exactly the same thing it would have done if it was written by hand.
Compared with Runtime Generic Information no extra information is stored in each instance and hence no extra runtime checks need to get done.
Compared with NextGen this approach is completely backwards compatible. NextGen looks like it was trying to achieve the same goals, but aside from non backwards compatibility also suffered from the fact that Vector<String> didn't extend AbstractList<String> causing other minor problems. Also this approach doesn't create 2 types per new types like NextGen does (although this wasn't a big deal anyway). All that said NextGen was in my opinion a much better approach than GJ and most of the others.
Compared to .NET common runtime this is java and doesn't require changes to the JVM.
Compared to Fully Generated Generic Classes the classes generated by this approach are very lightweight wrappers, not full blown classes and also it does have a base class making integration with legacy code simple. It should be noted that the functionality of the Fully Generated Generic Classes is the same as this approach, that can't be said for the other approaches.
Compared with JSR-14, this approach doesn't suffer from GJ's problems, also it should be clear what to expect from this approach. Hopefully JSR-14 can be changed before it is too late.

(a) How you intend generic methods to be translated.
Given that Vector and Vector<Object> are unrelated types,
what would that type be represented as in the byte code of
the method? In my approach Vector and Vector<Object> are related types. In fact the byte code signature of the existing method is exactly the same as it was in the legacy code using Vector.
To re-emphasize what I had said when explaining my approach:
System.out.println(Vector.class == Vector<Object>.class); // displays true
System.out.println(Vector.class == Vector<String>.class); // displays false
Vector vector1 = new Vector<Object>(); // legal
Vector<Object> vector2 = new Vector(); // legal
// Vector vector3 = new Vector<String>(); // illegal
// Vector<String> vector4 = new Vector(); // illegal
Vector<String> vector5 = new Vector<String>(); // legal
You must also handle the case where the type
parameter is itself a parameterized type in which the type
parameter is not statically bound to a ground instantiation.This is also very straightforward: (let me know if I have misunderstood you)
(translation of Vector given in my initial description)
public class SampleClass<TypeA> {
public static void main(String[] args) {
    System.out.println(new Vector<Vector<TypeA>>(10, 10));
}would get translated as:public class SampleClass {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
private static final Constructor $0 = Reflection.getDeclaredConstructor(Vector$$C16java_util_Vector.class, new Class[] {int.class, int.class});
static void $1(Constructor _0, int _1, int _2) {
    try {
      System.out.println(Reflection.newInstance(_0, new Object[] {new Integer(_1), new Integer(_2)}));
    catch (Exception ex) {
      throw (RuntimeException)ex;
public static void main(String[] args) {
    $1($0, 10, 10);
}and SampleClass<String> would get generated as:public class SampleClass$$C16java_lang_String {
private static final Constructor $0 = Reflection.getConstructor(Vector$$C37java_util_Vector$$C16java_lang_String.class, new Class[] {int.class, int.class});
public static void main(String[] args) {
    SampleClass.$1($0, 10, 10);
Also describe the implementation strategy for when these
methods are public or protected (i.e. virtual).As I said in my initial description that for non final, non static, non private method invocations a Method may be passed into the implementing synthetic method as a parameter.
Note: the following main method will display 'in B'.
class A {
public void foo() {
    System.out.println("in A");
class B extends A {
public void foo() {
    System.out.println("in B");
public class QuickTest {
public static void main(String[] args) {
    try {
      A.class.getMethod("foo", null).invoke(new B(), null);
    catch (Exception ex) {}
}This is very important as foo() may be overwritten by a subclass as it is here. By passing a Method to the synthetic implementation this guarantees that covariance, invariance and contra variance all work exactly the same way as in java. This is a fundamental problem with many other approaches.
(b) The runtime overhead associated with your translationAs we don't have a working solution to compare this to, performance comments are hard to state, but I hope this helps anyway.
The Class Load time is affected in 4 ways. i) All the Generic Bytes exist in the Base Class, hence they don't need to be read from storage. ii) The custom class loader, time to parse the name and failed finds before it finally gets to define the class. iii) The generation of the generic bytes to parametric bytes (basically involves changing bytes from the Constant Pool worked out from a new Parametric type, Utf8, Class and the new Parametric Constant types may all be effected) iv) time to do the static Reflection stuff (this is the main source of the overhead). Basically this 1 time per class overhead is nothing to be concerned with, and Sun could always optimize this part further.
The normal Runtime overhead (once Classes have been loaded) is affected mainly by reflection: On older JDKs the reflection was a lot slower, and so might have made a noticeable impact. On newer JDKs (since 1.4 I think), the reflection performance has been significantly improved. All the time consuming reflection is done once per class (stored in static fields). The normal reflection is very quick (almost identical to what is getting done without reflection). As the wrappers simply include a single method call to another method, these can be in-lined and hence made irrelevant. Furthermore it is not too difficult to make a parameter that would include small methods in the wrapper classes, as this does not affect functionality in the slightest, however in my testing I have found this to be unnecessary.
(c) The space overhead (per instantiation)There are very small wrapper classes (one per new Type) that simply contain all non private methods, with single method calls to the implementing synthetic method. They also include any fields that were in the original class along with other synthetic fields used to store reflected information, so that the slow reflection only gets done once per new Type.
(d) The per-instance space overheadNone.
(e) Evidence that the proposed translation is sound and well-defined for all relevant cases (see below)Hope this is enough, if not let me know what extra proof you need.
(f) Evidence for backward compatibility
(For example, how does an old class file that passes a Vector
to some method handle the case when the method receives a Vector<T>
where T is a type parameter? In your translation these types are unrelated.)As explained above, in my approach these are only unrelated for T != Object, in the legacy case T == Object, hence legacy code passing in Vector is exactly the same as passing in Vector<Object>.
(g) Evidence for forward compatibility
(How, exactly, do class files that are compiled with a generics compiler run on an old VM)They run exactly the same way, the byte codes from this approach are all legal java, and all legal java is also legal in this approach. In order to take advantage of the Generics the Custom Class Loader would need to be used or else one would get ClassNotFoundExceptons, the same way they would if they tried using Collections on an old VM without the Collections there. The Custom Class Loader even works on older VMs (note it may run somewhat slower on older VMs).
(h) A viable implementation strategyType specific instantiations are at Class Load time, when the Custom Class Loader gets asked for a new Class, it then generates it.
The type specific instantiations are never shipped as they never get persisted. If you really wanted to save them all you need to do is save them with the same name (with the $$ and _'s etc), then the class loader would find them instead of generating them. There is little to be gained by doing this and the only reason I can think of for doing such a thing would be if there was some reason why the target VM couldn't use the Custom Class Loader (the Reflection class would still need to be sent as well, but that is nothing special). Basically they are always generated at Runtime unless a Class with the same name already exists in which case it would be used.
The $GENERIC_DESCRIPTOR and $GENERIC_BYTES from the base class along with the new Type name are all that is required to generate the classes at runtime. However many other approaches can achieve the same thing for the generation, and approaches such as NextGen's template approach may be better. As this generation is only done once per class I didn't put much research into this area. The way it currently works is that the $GENERIC_DESCRIPTOR are basically used to verify that a malicious class files is not trying to create a non Type Safe Type, ie new Sample<Object>() when the class definition said class Sample<TypeA extends Button>. The $GENERIC_BYTES basically correspond to the normal bytes of a wrapper class file, except that in the constant pool it has some constants of a new Parametric Constant type that get replaced at class load time. These parametric constants (along with possibly Utf8 and Class constants) are replaced by the Classes at the end of the new type name, a little more complex than that but you probably get the general idea.
These fine implementation details don't affect the approach so much anyway, as they basically come down to class load time performance. Much of the information in the $GENERIC_BYTES could have been worked out by reflection on the base type, however at least for now simply storing the bytes is a lot easier.
Note: I have made a small syntax change to the requested class:
public T(X datum) --> public T<X>(X datum)
class T<X> {
private X datum;
public T<X>(X datum) {
    this.datum = datum;
public T<T<X>> box() {
    return new T<T<X>>(this);
public String toString() {
    return datum.toString();
public static void main(String[] args) {
    T<String> t = new T<String>("boo!");
    System.out.println(t.box().box());
}would get translated as:
class T {
public static final Class[][] $GENERIC_DESCRIPTOR = {{Object.class}};
public static final byte[] $GENERIC_BYTES = {/*Generic Bytes Go Here*/};
private Object datum;
private static final Field $0 = Reflection.getDeclaredField(T.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C1T.class, new Class[] {T.class});
static void $2(Field _0, Object _1, Object _2) {
    Reflection.set(_0, _1, _2);
static Object $3(Constructor _0, Object _1) {
    try {
      return Reflection.newInstance(_0, new Object[] {_1});
    catch (Exception ex) {
      throw (RuntimeException)ex;
static String $4(Field _0, Object _1) {
    return Reflection.get(_0, _1).toString();
static void $5() {
    T$$C16java_lang_String t = new T$$C16java_lang_String("boo!");
    System.out.println(t.box().box());
public T(Object datum) {
    $2($0, this, datum);
public T$$C1T box() {
    return (T$$C1T)$3($1, this);
public String toString() {
    return $4($0, this);
public static void main(String[] args) {
    $5();
}as the generic bytes aren't very meaningful and by no means a requirement to this approach (NextGen's template method for generation may work just as well), here are the generated classes with some unused code commented out instead:
class T$$C28T$$C22T$$C16java_lang_String {
private T$$C22T$$C16java_lang_String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C28T$$C22T$$C16java_lang_String.class, "datum");
// private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C34T$$C28T$$C22T$$C16java_lang_String.class, new Class[] {T$$C28T$$C22T$$C16java_lang_String.class});
public T$$C28T$$C22T$$C16java_lang_String(T$$C22T$$C16java_lang_String datum) {
    T.$2($0, this, datum);
// public T$$C34T$$C28T$$C22T$$C16java_lang_String box() {
//    return (T$$C34T$$C28T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C22T$$C16java_lang_String {
private T$$C16java_lang_String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C22T$$C16java_lang_String.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C28T$$C22T$$C16java_lang_String.class, new Class[] {T$$C22T$$C16java_lang_String.class});
public T$$C22T$$C16java_lang_String(T$$C16java_lang_String datum) {
    T.$2($0, this, datum);
public T$$C28T$$C22T$$C16java_lang_String box() {
    return (T$$C28T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C1T {
private T datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C1T.class, "datum");
// private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C6T$$C1T.class, new Class[] {T$$C1T.class});
public T$$C1T(T datum) {
    T.$2($0, this, datum);
// public T$$C6T$$C1T box() {
//    return (T$$C6T$$C1T)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
class T$$C16java_lang_String {
private String datum;
private static final Field $0 = Reflection.getDeclaredField(T$$C16java_lang_String.class, "datum");
private static final Constructor $1 = Reflection.getDeclaredConstructor(T$$C22T$$C16java_lang_String.class, new Class[] {T$$C16java_lang_String.class});
public T$$C16java_lang_String(String datum) {
    T.$2($0, this, datum);
public T$$C22T$$C16java_lang_String box() {
    return (T$$C22T$$C16java_lang_String)T.$3($1, this);
public String toString() {
    return T.$4($0, this);
public static void main(String[] args) {
    T.$5();
}the methods from the Reflection class used in these answers not given in my initial description are:
public static final Object newInstance(Constructor aConstructor, Object[] anArgsArray) throws Exception {
    try {
      return aConstructor.newInstance(anArgsArray);
    catch (InvocationTargetException ex) {
      Throwable cause = ex.getCause();
      if (ex instanceof Exception) {
        throw (Exception)ex;
      throw new Error(ex.getCause());
    catch (Exception ex) {
      throw new Error(ex);
public static final Constructor getDeclaredConstructor(Class aClass, Class[] aParameterTypesArray) {
    try {
      Constructor constructor = aClass.getDeclaredConstructor(aParameterTypesArray);
      constructor.setAccessible(true);
      return constructor;
    catch (Exception ex) {
      throw new Error(ex);
}

I have just started to use Muse for our design agency and learning how to build ourselves a new site, I have manged to create a basic lightbox which contains sliding images, what I need to do now is have a pop up window which goes into detail about the pr

I have just started to use Muse for our design agency and learning how to build ourselves a new site, I have managed to create a basic lightbox which contains sliding images, what I need to do now is have a pop up window which goes into detail about the projects, what I would like is a piece of text or icon that when you roll over it and then click a separate window pops up with additional information in, once finished reading the info you can then click to close the box, any advice on how to do this?

The best way to do what you're asking is with the Composition widget. Start with the Tooltip preset, which, by default shows the info on rollover. You can change the option to show on click, which is what you're after. You can also add the close button or have the info disappear on rollout.
David

Three questions about the creation of secondary indexes in ODS design mode

1. When we right click the Indexes folder in ODS design to select Create to create the Index folder 010, a small window pops up with a check box called "Unique", do we have to check this checkbox to create folder 010?
2. If we would like to include 3 InfoObjects into the secondary indexes, then how many folders we need to create? Need to create 3 folders like 010, 020, and 030 and place the 3 InfoObj. into the 3 folder respectively or create only one folder 010 and place all the 3 InfoObj. into this one folder 010?
3. In SAP documentation titled "BW Performance Tuning" about the Indices, it says "If the (uncompressed) F fact table is small, it is usually faster to drop the secondary (bitmap) indices before the load and build them up after the load"
Someone here says secondary index is only for ODS other than for cubes, but from the above statement, F fact table is related to cubes, then how to explain it? Also the above statement is talking above the variant in process chain that when you bring in a variant to load data to cube, then the drop index and generate index variants will be automatically created, does it refer to this? And what's bitmap index?
Thanks in advance and we will continue to give you reward points!

Hi Kevin,
Cube has Secondary index's. The index's that we find in the Manage of the Cube are the Secondary Index's. Please check the following link for more information.
http://help.sap.com/saphelp_erp2004/helpdata/en/80/1a6473e07211d2acb80000e829fbfe/frameset.htm
Also, to know about Unique indexes, use the following link
http://help.sap.com/saphelp_erp2004/helpdata/en/9b/c743f5b40711d194f900a0c929b3c3/frameset.htm
"The indexes displayed are the secondary indexes of the F and E fact tables for the InfoCube. The primary indexes and those defined by the user are not displayed. " (SAP help).
This should answer your questions.
Regards,
Praveen.

Question about the BOOperation READ in the UI Designer

Hi,
I just noticed that the BOOperation Read in the UI Designer can use the NodeID, the KeyNavigation and the alternativeKey.
About the AlternativeKey I have no doubts... but what about the NodeID and the KeyNavigation? Can somebody explain me the differences between these keys?

Hi Alessandro,
I created a custom BO:
businessobject StudioInformationHandler {
[AlternativeKey] element CustomerUUID : UUID;
element CustomerID : ID;
association ToCustomer to Customer;
association ToStudioInformation to StudioInformation;
That is an add-on to the customer.
I made an embedded component for the customer based on this BO. The EC has the CustomerUUID and CustomerID in the inport. In the event handler I try to read the BO instance with BOOperation.
When debugging my script in After-Modify I expect to have the persistent instance, but I have a new one. I can query my BO and get the persistent instance.
I think I make a mistake in the BOOperation but I don't know what's wrong. Another suggestion is that data binding in my EC is not as expected.
I attach a screenshot from my event handler and from the data model.
The CustomerID is not used at the moment. I tried it with the ID and UUID, but both didn't work for me.
I think there is something I didn't understand yet.
kind regards,
Frank

I would like to inquire about the design of iphone 5 .. why, iphone 5 is designed with a slightly wider screen ..?

I would like to inquire about the design of iphone 5 .. why, iphone 5 is designed with a slightly wider screen ..?

Apple's design team was looking to build an iphone with a screen that had a 16:9 aspect ratio. Call it pressure to keep up with the competition.
Plus, LTE is so FAST! Time to turn up the speed!

Local Repository User Rights for the Data Designer

Hello,
we are using the Data Services with 4 users and one local repository stored on the server.
Is it possible to hide in the Data Designer foreign objects and projects from other users in the local repository? What's the best practice for that, for every user a seperate repository or to restrict the repository rights with the cmc?
Our system:
Windows Server 2008
Data Services 4.0 SP1
IBM DB2 9.7 (Repository)
Thanks for some tips and hints!

Hi Alexander,
At any point in time, you should only have one user connected to one repository in Designer.
If two users are using the same repository at the same time, then there is a risk of corruption of repository objects.
Best practice is to have a repository for each (concurrent) developer and a central repository for version management.
Depending how testing is organised, you might also need to have repositories for unit test / QA (UAT) and finally a production repository.
For good measure, an additional central reposotiry for production can be valuable:
- if development for new project start before the 'previous' project has gone into live.
- You can prepare go-live by checking in all the objects required for live into central-production first.
- It's the final safety measure, if objects in production are corrupted and dev/test systems have modified versions.
So, a typical landscape would look like this:
DEVELOPMENT:
n number of development repositories, one for each developer
1 test repository (local)
1 dev central repository
TEST
1 UAT repository (local)
PROD
1 PROD repository (local)
1 central repository
Jan.

Easy installation of the Repository Object Browser - Web Designer do it now

As the original developer of the Oracle Designer Web Assistant that has been part of Oracle Designer since 2003 as Repository Object Browser (ROB)- in patch-sets for Design 6i and 9i as well as the standard 10g release - I would like to provide you all with a very simple, 10 minute configuration guide to get you all going with the ROB.
ROB is really very simple to get up and running and it offers a very useful set of functionality.
For instructions, please look at the article I posted recently on our weblog: http://technology.amis.nl/blog/index.php?p=744
Enjoy!
Lucas Jellema

I also need to be able to control how JRE is installed, over an intrane and the web, because my application requires ebcidic 277 from the extra libs, I have to be sure the end user installs this, and our customers are still using products from net banks which still use MSJVM, so I have to disable the SUN JVM Plugin.
I have not found a solution to pass parameters to installer from web page object.
The best solution I have come up with so far was to create a simple native installer, which i have put into a .cab file with an .inf file, signed this and placed this on a web page.
The user clicks yes on a single security warning dialog, and then the installer is downloaded and started, this then pulls JRE from web server to PC and executes the installer with a /s plus the parameter settings needed for install a specific installation.
gary

About the DWDM 15454 optical ring design questions.

1 Question
We have 3 ONS 15454 in A,B,C each place. The connection between different locations is a pair of single mode fiber. The topology is A>B>C>A. The A is main datacenter.
We want to make a redundancy design based on ROADM. The normal transmission is A to B to C to A. For example, when the problem occurred between C and A, like CxA. We want to change the data transfer direction to C>B>A.
How could I do that through the 15454 configuration software CTC? Which protocol should I use? I am newbie in the optical network. Please give me an easy grasping answer. (Please don't change the topology because we not only have A,B,C we also have other 3 locations to join in the optical ring. I just want to use A B C to make the question easy to be answered)
2 Question
The 15454-GE-XPE card mode made me a little confused. Our each location have 2 15216 MUX/DEMUX patch Panel Odd. One for MUX to next location. One for DEMUX from last location. Does that mean I don’t need to open the GE-XPE cards’ MXP mode?
The reason I want to use L2 mode is that we have 2 GE-XPE cards for each location for different department function. The connection is 1st SFP port from GE-XPE to 6509 supervisor engine 2T active. 11th SFP port connects to 6509 supervisor 2T standby. The 11th SFP will have no data until the
active supervisor 2T changed to down. I am worried about if I open the MXP mode for GE-XPE. The 21th XPF gets data from 15216 DEMUX panel and transfers it to 6509 engine 2T through 1st SFP. But 6509 can’t transfer the data back to 22th XPF through the 11th SFP on the GE-XPE. Because the 11th SFP connection is on standby engine 2T.
The question is what is the best way to make the right data flow direction from 15216 DEMUX through 6509 and back to 15216 MUX panel.
Thank you for the reading and help!
I will do my best to reply every feedback.:)

about Question-1
there are two ways to achieve your requirements.
use PSM card or second way is to use WSON.
PSM card is easy to install and it will cost less.
for WSON solution, your wavelength will switch automatically on fiber cut, but for this you have to make two nodes omni-directional that is source and drop nodes for that wavelength which seeks proteciton.
to make omnidirectional you need extra piece of hardware.
if your node has SMR2 cards, than you need one more SMR2 to make it omni-directional.
if its WXC than you need one more WXC, plus PRE and BST amplifiers.
so i think, just go for PSM cards :-)
about Question-2
The main question is if I open the 10GE MXP mode on the 15454-GE-XPE card, the port 1~10 can’t do any communication with port 11~20 unless I connect them with a SFP switch, is it right?
yes this is correct.
Another problem is I confused about the muxponder mode GE-XPE and the 15216 MUX/DEMUX Patch Panel. Are they doing the same job MUX/DEMUX?
no there is difference.
there are three modes on GE_XPE card.
10GE MXP mode:
if you select this mode.
than it will multiplex all the traffic coming on port 1 to port 10 and trasnmit it through port 21-1.
and traffic received on ports 11 to ports 20 is multiplexed and transmit it through port 22-1.
in other words, all traffic coming on port-1 to port-10 is encapsulated over a OTN/SONET/SDH and transmitted via port 21. same for port 11 to port 20.
20GE MXP mode:
all the traffic recevied over por-1 to port-20 is multiplexed and transmitted through port 21, in this port port 22 is not used.
Layer-2 mode.
you have to proviion QinQ and SVLANS to pass traffic.
15216 MUX/DMUX are entirely different, they are used to multiplex and de-multiplex wavelength.
so if we have 5 GE_XPE cards on each node A and node B.
and you want to connected each card with each other, suppose port 21 of each card on each node is connected with each other.
than you need 10 fibers to connect them, one for each Tx----------Rx.
so instead of doing this, people use MUX/DMUX, in your case it is 15216 MUX/DMUX
so trunk port 21 of each 5 cards will be connected with these MUX/DMUX and than the signal is transposrted is this way.
please go through this picture.

Oracle designer 6i. Info about the current schema. Can't get tablespace inf

Oracle designer 6i. I am running sql against the views to get info about the current schema.
I can't get the tablespace names for the tables used in the latest version of a schema.
eg the below sql return far too many rows.
select distinct (lower(ti.GLOBAL_SYNONYM_NAME)||'*'||ts.name )
from
ci_application_systems app,
ci_table_implementations ti,
ci_tablespaces ts,
ci_storage_definitions sd
,sdd_folder_members mem
,ci_table_definitions td
where
     app.OWNING_USER = '$OWNER' and
     app.NAME = '$APP_NAME''' and
app.ivid = (select MAX(ivid) from ci_application_systems app2 where app2.name = '$APP_NAME'') and
mem.PARENT_IVID = app.IVID and
mem.MEMBER_OBJECT = td.ID
and ti.GLOBAL_SYNONYM_NAME IS NOT NULL
     and ti.STORAGE_DEFINITION_REFERENCE = ts.STORAGE_DEFINITION_REFERENCE
and ts.STORAGE_DEFINITION_REFERENCE = sd.ID

Hi Neil,
Thanks for your suggestion. I thought I tried all combinations of database, catalog and schema names and all different orders to connect, associate the connection and generate entities, but it seems I did not try this one. I did exactly what you suggest, except for the fact that I connected to the database before associating the connection to the project.
It partially works now. I can generate Entities. Once I have generated an entity, all generated private member variables become red underlined, because table "null" for columns "xyz" could not be resolved. And the drop down box for columns in the JPA Details pane still doesn't get populated. The latter can be fixed by selecting the proper schema for the entity, which results in a @Table(schema="xyz") annotation. However, I expected this to be done automatically when the Entity was generated.
The error about not being able to resolve the columns still exists. I tried to add a @Column(name="ASDF") annotation (because the columns names are all capital, while the member variables are lowercase), but that doesn't resolve the problem.
I hope this gives you a clue to solve the problem!
Bart

About The Repository Design Approach

Similar Messages

Maybe you are looking for