ADBSDataManagement.java
0001 //
0002 // This file is generated by MetaBoss Ver 1.4.0001 at Thu Dec 15 22:36:26 EST 2005
0003 // MetaBoss is Copyright 2000-2005 © Softaris Pty.Ltd. All Rights Reserved.
0004 // Content of this file is Copyright 2000-2005 © Softaris Pty. Ltd. All Rights Reserved.
0005 // This content is licensed under Open Source Gnu Public License (GPL)
0006 // Full terms and conditions of GPL can be found found at www.gnu.org
0007 //
0008 // The generator class is com.metaboss.sdlctools.services.codegeneration.servicemoduleadaptergenerator.generic.stringstructures.BSAdapterGeneratorImpl
0009 package com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport;
0010 
0011 import javax.naming.Context;
0012 import javax.naming.InitialContext;
0013 import javax.naming.NamingException;
0014 import com.metaboss.enterprise.bs.BSException;
0015 import com.metaboss.enterprise.datatypes.DataTypeValidationException;
0016 import com.metaboss.enterprise.datatypes.DataTypeFieldValidationException;
0017 import com.metaboss.enterprise.messages.Message;
0018 
0019 /** This class is an adapter between siple (non MetaBoss compliant) java client code and enterprise services.
0020   * It offers client code  a simple String based access to the enterprise services. This simplicity 
0021   * comes at the expence of losing the benefits strong data types, such as compile time detection of 
0022   * some data validation errors */
0023 public class ADBSDataManagement
0024 {
0025 
0026     /** This class contains an input to the getStudent operation */
0027     public static final class PXSTGetStudentInput
0028     {
0029     /** <p>The unique key referring to the instance of Student to be retrieved.</p>
0030       */
0031         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentKey StudentKey;
0032     }
0033 
0034     /** This class contains result of the getStudent operation. */
0035     public static final class PXSTGetStudentResult
0036     {
0037         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
0038         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0039     /** <p>Details of a particuar Student found in the domain.</p>
0040       */
0041         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails Student;
0042     }
0043 
0044     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentInput enterprise data structure and
0045       * PXSTGetStudentInput string based proxy structure.
0046       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0047     public static final class TRSTGetStudentInput
0048     {
0049         private TRSTGetStudentInput ()
0050         {
0051         }
0052 
0053         /** This method converts string based operation input structure to the enterprise operation input structure. */
0054         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentInput fromProxyPXSTGetStudentInput pProxythrows DataTypeFieldValidationException
0055         {
0056             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentInput();
0057             try
0058             {
0059                 lStruct.setStudentKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentKey.fromProxypProxy.StudentKey));
0060             }
0061             catch (DataTypeValidationException e)
0062             {
0063                 throw new DataTypeFieldValidationException("StudentKey", e);
0064             }
0065             return lStruct;
0066         }
0067     }
0068 
0069     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentResult enterprise data structure and
0070       * PXSTGetStudentResult string based proxy structure.
0071       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0072     public static final class TRSTGetStudentResult
0073     {
0074         private TRSTGetStudentResult ()
0075         {
0076         }
0077 
0078         /** This method converts enterprise data structure to the string based proxy structure. */
0079         public static PXSTGetStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetStudentResult pStruct)
0080         {
0081             PXSTGetStudentResult lProxy = new PXSTGetStudentResult();
0082             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
0083             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0084             lProxy.Student = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.toProxypStruct.getStudent());
0085             return lProxy;
0086         }
0087     }
0088 
0089     /** Retrieves details of a particular Student instance from the domain. Instance is identified by key structure.
0090       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0091       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0092       @exception BSException re-thrown from enteprise service component */
0093     public ADBSDataManagement.PXSTGetStudentResult getStudentADBSDataManagement.PXSTGetStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
0094     {
0095         Context lContext = new InitialContext();
0096         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0097         return TRSTGetStudentResult.toProxy(lService.getStudent(TRSTGetStudentInput.fromProxy(pInput)));
0098     }
0099 
0100     /** This class contains an input to the createStudent operation */
0101     public static final class PXSTCreateStudentInput
0102     {
0103     /** <p>Proposed details of the new instance of the Student in the domain.</p>
0104       */
0105         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails ProposedDetails;
0106     }
0107 
0108     /** This class contains result of the createStudent operation. */
0109     public static final class PXSTCreateStudentResult
0110     {
0111         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentCreationDuplicateKeyError DuplicateKeyErrorMessage;
0112         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0113     /** <p>Details of an instance after successfull creation. Mostly the same as the details passed in, but will have some autogenerated fields populated.</p>
0114       */
0115         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails CreatedDetails;
0116     }
0117 
0118     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentInput enterprise data structure and
0119       * PXSTCreateStudentInput string based proxy structure.
0120       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0121     public static final class TRSTCreateStudentInput
0122     {
0123         private TRSTCreateStudentInput ()
0124         {
0125         }
0126 
0127         /** This method converts string based operation input structure to the enterprise operation input structure. */
0128         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentInput fromProxyPXSTCreateStudentInput pProxythrows DataTypeFieldValidationException
0129         {
0130             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentInput();
0131             try
0132             {
0133                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.fromProxypProxy.ProposedDetails));
0134             }
0135             catch (DataTypeValidationException e)
0136             {
0137                 throw new DataTypeFieldValidationException("ProposedDetails", e);
0138             }
0139             return lStruct;
0140         }
0141     }
0142 
0143     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentResult enterprise data structure and
0144       * PXSTCreateStudentResult string based proxy structure.
0145       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0146     public static final class TRSTCreateStudentResult
0147     {
0148         private TRSTCreateStudentResult ()
0149         {
0150         }
0151 
0152         /** This method converts enterprise data structure to the string based proxy structure. */
0153         public static PXSTCreateStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateStudentResult pStruct)
0154         {
0155             PXSTCreateStudentResult lProxy = new PXSTCreateStudentResult();
0156             lProxy.DuplicateKeyErrorMessage = TRMOStudentCreationDuplicateKeyError.toProxy(pStruct.getDuplicateKeyError());
0157             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0158             lProxy.CreatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.toProxypStruct.getCreatedDetails());
0159             return lProxy;
0160         }
0161     }
0162 
0163     /** Creates new instance of Student in the domain.
0164       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0165       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0166       @exception BSException re-thrown from enteprise service component */
0167     public ADBSDataManagement.PXSTCreateStudentResult createStudentADBSDataManagement.PXSTCreateStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
0168     {
0169         Context lContext = new InitialContext();
0170         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0171         return TRSTCreateStudentResult.toProxy(lService.createStudent(TRSTCreateStudentInput.fromProxy(pInput)));
0172     }
0173 
0174     /** This class contains an input to the deleteStudent operation */
0175     public static final class PXSTDeleteStudentInput
0176     {
0177     /** <p>The unique key referring to the instance of Student to be deleted.</p>
0178       */
0179         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentKey StudentKey;
0180     }
0181 
0182     /** This class contains result of the deleteStudent operation. */
0183     public static final class PXSTDeleteStudentResult
0184     {
0185         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
0186         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0187     }
0188 
0189     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentInput enterprise data structure and
0190       * PXSTDeleteStudentInput string based proxy structure.
0191       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0192     public static final class TRSTDeleteStudentInput
0193     {
0194         private TRSTDeleteStudentInput ()
0195         {
0196         }
0197 
0198         /** This method converts string based operation input structure to the enterprise operation input structure. */
0199         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentInput fromProxyPXSTDeleteStudentInput pProxythrows DataTypeFieldValidationException
0200         {
0201             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentInput();
0202             try
0203             {
0204                 lStruct.setStudentKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentKey.fromProxypProxy.StudentKey));
0205             }
0206             catch (DataTypeValidationException e)
0207             {
0208                 throw new DataTypeFieldValidationException("StudentKey", e);
0209             }
0210             return lStruct;
0211         }
0212     }
0213 
0214     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentResult enterprise data structure and
0215       * PXSTDeleteStudentResult string based proxy structure.
0216       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0217     public static final class TRSTDeleteStudentResult
0218     {
0219         private TRSTDeleteStudentResult ()
0220         {
0221         }
0222 
0223         /** This method converts enterprise data structure to the string based proxy structure. */
0224         public static PXSTDeleteStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteStudentResult pStruct)
0225         {
0226             PXSTDeleteStudentResult lProxy = new PXSTDeleteStudentResult();
0227             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
0228             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0229             return lProxy;
0230         }
0231     }
0232 
0233     /** Deletes existing instance of Student in the domain.
0234       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0235       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0236       @exception BSException re-thrown from enteprise service component */
0237     public ADBSDataManagement.PXSTDeleteStudentResult deleteStudentADBSDataManagement.PXSTDeleteStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
0238     {
0239         Context lContext = new InitialContext();
0240         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0241         return TRSTDeleteStudentResult.toProxy(lService.deleteStudent(TRSTDeleteStudentInput.fromProxy(pInput)));
0242     }
0243 
0244     /** This class contains an input to the getAllStudentsCount operation */
0245     public static final class PXSTGetAllStudentsCountInput
0246     {
0247     }
0248 
0249     /** This class contains result of the getAllStudentsCount operation. */
0250     public static final class PXSTGetAllStudentsCountResult
0251     {
0252     /** <p>Number of Students found in the domain.</p>
0253       <p>The range of string values this field can be populated with is governed by the 
0254       {@link com.almamater.types.core.CollectionSize CollectionSize} datatype.</p>
0255       */
0256         public String StudentsCount;
0257     }
0258 
0259     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountInput enterprise data structure and
0260       * PXSTGetAllStudentsCountInput string based proxy structure.
0261       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0262     public static final class TRSTGetAllStudentsCountInput
0263     {
0264         private TRSTGetAllStudentsCountInput ()
0265         {
0266         }
0267 
0268         /** This method converts string based operation input structure to the enterprise operation input structure. */
0269         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountInput fromProxyPXSTGetAllStudentsCountInput pProxythrows DataTypeFieldValidationException
0270         {
0271             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountInput();
0272             return lStruct;
0273         }
0274     }
0275 
0276     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountResult enterprise data structure and
0277       * PXSTGetAllStudentsCountResult string based proxy structure.
0278       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0279     public static final class TRSTGetAllStudentsCountResult
0280     {
0281         private TRSTGetAllStudentsCountResult ()
0282         {
0283         }
0284 
0285         /** This method converts enterprise data structure to the string based proxy structure. */
0286         public static PXSTGetAllStudentsCountResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsCountResult pStruct)
0287         {
0288             PXSTGetAllStudentsCountResult lProxy = new PXSTGetAllStudentsCountResult();
0289             com.almamater.types.core.CollectionSize lStudentsCount = pStruct.getStudentsCount();
0290             if (lStudentsCount != null)
0291                lProxy.StudentsCount = lStudentsCount.toString();
0292             return lProxy;
0293         }
0294     }
0295 
0296     /** Retrieves count of all Students present in the domain.
0297       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0298       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0299       @exception BSException re-thrown from enteprise service component */
0300     public ADBSDataManagement.PXSTGetAllStudentsCountResult getAllStudentsCountADBSDataManagement.PXSTGetAllStudentsCountInput pInputthrows BSException, DataTypeValidationException, NamingException
0301     {
0302         Context lContext = new InitialContext();
0303         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0304         return TRSTGetAllStudentsCountResult.toProxy(lService.getAllStudentsCount(TRSTGetAllStudentsCountInput.fromProxy(pInput)));
0305     }
0306 
0307     /** This class contains an input to the getAllStudents operation */
0308     public static final class PXSTGetAllStudentsInput
0309     {
0310     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned Students will be sorted in accordance with these instructions.</p>
0311       <p>The range of string values this field can be populated with is governed by the 
0312       {@link com.almamater.crs.types.system.courses.StudentOrderingInstruction StudentOrderingInstruction} datatype.</p>
0313       */
0314         public String[] OrderingInstructions;
0315     }
0316 
0317     /** This class contains result of the getAllStudents operation. */
0318     public static final class PXSTGetAllStudentsResult
0319     {
0320         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0321     /** <p>Details of all Students found in the domain.</p>
0322       */
0323         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails[] Students;
0324     }
0325 
0326     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsInput enterprise data structure and
0327       * PXSTGetAllStudentsInput string based proxy structure.
0328       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0329     public static final class TRSTGetAllStudentsInput
0330     {
0331         private TRSTGetAllStudentsInput ()
0332         {
0333         }
0334 
0335         /** This method converts string based operation input structure to the enterprise operation input structure. */
0336         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsInput fromProxyPXSTGetAllStudentsInput pProxythrows DataTypeFieldValidationException
0337         {
0338             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsInput();
0339             try
0340             {
0341                 if (pProxy.OrderingInstructions != null)
0342                 {
0343                      com.almamater.crs.types.system.courses.StudentOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.StudentOrderingInstruction[pProxy.OrderingInstructions.length];
0344                     for (int i = 0; i < lStructArray.length; i++)
0345                     {
0346                         String lProxyElement = pProxy.OrderingInstructions[i];
0347                         if (lProxyElement != null)
0348                            lStructArray[i= com.almamater.crs.types.system.courses.StudentOrderingInstruction.createFromString(lProxyElement);
0349                     }
0350                     lStruct.setOrderingInstructions(lStructArray);
0351                 }
0352             }
0353             catch (DataTypeValidationException e)
0354             {
0355                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
0356             }
0357             return lStruct;
0358         }
0359     }
0360 
0361     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsResult enterprise data structure and
0362       * PXSTGetAllStudentsResult string based proxy structure.
0363       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0364     public static final class TRSTGetAllStudentsResult
0365     {
0366         private TRSTGetAllStudentsResult ()
0367         {
0368         }
0369 
0370         /** This method converts enterprise data structure to the string based proxy structure. */
0371         public static PXSTGetAllStudentsResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllStudentsResult pStruct)
0372         {
0373             PXSTGetAllStudentsResult lProxy = new PXSTGetAllStudentsResult();
0374             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0375             lProxy.Students = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.toProxyArraypStruct.getStudents());
0376             return lProxy;
0377         }
0378     }
0379 
0380     /** Retrieves details of all Students present in the domain.
0381       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0382       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0383       @exception BSException re-thrown from enteprise service component */
0384     public ADBSDataManagement.PXSTGetAllStudentsResult getAllStudentsADBSDataManagement.PXSTGetAllStudentsInput pInputthrows BSException, DataTypeValidationException, NamingException
0385     {
0386         Context lContext = new InitialContext();
0387         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0388         return TRSTGetAllStudentsResult.toProxy(lService.getAllStudents(TRSTGetAllStudentsInput.fromProxy(pInput)));
0389     }
0390 
0391     /** This class contains an input to the getSubsetOfStudents operation */
0392     public static final class PXSTGetSubsetOfStudentsInput
0393     {
0394     /** <p>Zero-based offset from the first entity details to be returned to the beginning of the whole collection of Students present in domain.</p>
0395       <p>The range of string values this field can be populated with is governed by the 
0396       {@link com.almamater.types.core.CollectionOffset CollectionOffset} datatype.</p>
0397       */
0398         public String FirstRecordOffset;
0399     /** <p>The desired maximum number of detail records to be returned. Note that actual number of details returned might be lower if domain does not have sufficient number of Students.</p>
0400       <p>The range of string values this field can be populated with is governed by the 
0401       {@link com.almamater.types.core.SubsetSize SubsetSize} datatype.</p>
0402       */
0403         public String RequiredMaxSize;
0404     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned subset of the Students will be cut out after sorting of the whole set has been done in accordance with these instructions.</p>
0405       <p>The range of string values this field can be populated with is governed by the 
0406       {@link com.almamater.crs.types.system.courses.StudentOrderingInstruction StudentOrderingInstruction} datatype.</p>
0407       */
0408         public String[] OrderingInstructions;
0409     }
0410 
0411     /** This class contains result of the getSubsetOfStudents operation. */
0412     public static final class PXSTGetSubsetOfStudentsResult
0413     {
0414         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0415     /** <p>Details of all Students found in the domain starting from specified offset and spanning no more than required maximum number of records.</p>
0416       */
0417         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails[] Students;
0418     }
0419 
0420     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsInput enterprise data structure and
0421       * PXSTGetSubsetOfStudentsInput string based proxy structure.
0422       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0423     public static final class TRSTGetSubsetOfStudentsInput
0424     {
0425         private TRSTGetSubsetOfStudentsInput ()
0426         {
0427         }
0428 
0429         /** This method converts string based operation input structure to the enterprise operation input structure. */
0430         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsInput fromProxyPXSTGetSubsetOfStudentsInput pProxythrows DataTypeFieldValidationException
0431         {
0432             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsInput();
0433             try
0434             {
0435                 lStruct.setFirstRecordOffset(com.almamater.types.core.CollectionOffset.createFromString(pProxy.FirstRecordOffset));
0436             }
0437             catch (DataTypeValidationException e)
0438             {
0439                 throw new DataTypeFieldValidationException("FirstRecordOffset", e);
0440             }
0441             try
0442             {
0443                 lStruct.setRequiredMaxSize(com.almamater.types.core.SubsetSize.createFromString(pProxy.RequiredMaxSize));
0444             }
0445             catch (DataTypeValidationException e)
0446             {
0447                 throw new DataTypeFieldValidationException("RequiredMaxSize", e);
0448             }
0449             try
0450             {
0451                 if (pProxy.OrderingInstructions != null)
0452                 {
0453                      com.almamater.crs.types.system.courses.StudentOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.StudentOrderingInstruction[pProxy.OrderingInstructions.length];
0454                     for (int i = 0; i < lStructArray.length; i++)
0455                     {
0456                         String lProxyElement = pProxy.OrderingInstructions[i];
0457                         if (lProxyElement != null)
0458                            lStructArray[i= com.almamater.crs.types.system.courses.StudentOrderingInstruction.createFromString(lProxyElement);
0459                     }
0460                     lStruct.setOrderingInstructions(lStructArray);
0461                 }
0462             }
0463             catch (DataTypeValidationException e)
0464             {
0465                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
0466             }
0467             return lStruct;
0468         }
0469     }
0470 
0471     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsResult enterprise data structure and
0472       * PXSTGetSubsetOfStudentsResult string based proxy structure.
0473       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0474     public static final class TRSTGetSubsetOfStudentsResult
0475     {
0476         private TRSTGetSubsetOfStudentsResult ()
0477         {
0478         }
0479 
0480         /** This method converts enterprise data structure to the string based proxy structure. */
0481         public static PXSTGetSubsetOfStudentsResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfStudentsResult pStruct)
0482         {
0483             PXSTGetSubsetOfStudentsResult lProxy = new PXSTGetSubsetOfStudentsResult();
0484             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0485             lProxy.Students = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.toProxyArraypStruct.getStudents());
0486             return lProxy;
0487         }
0488     }
0489 
0490     /** Retrieves details of the required subset of Students present in the domain.
0491       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0492       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0493       @exception BSException re-thrown from enteprise service component */
0494     public ADBSDataManagement.PXSTGetSubsetOfStudentsResult getSubsetOfStudentsADBSDataManagement.PXSTGetSubsetOfStudentsInput pInputthrows BSException, DataTypeValidationException, NamingException
0495     {
0496         Context lContext = new InitialContext();
0497         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0498         return TRSTGetSubsetOfStudentsResult.toProxy(lService.getSubsetOfStudents(TRSTGetSubsetOfStudentsInput.fromProxy(pInput)));
0499     }
0500 
0501     /** This class contains an input to the updateStudent operation */
0502     public static final class PXSTUpdateStudentInput
0503     {
0504     /** <p>Proposed new details of the existing instance of the Student. Only identifier fields and fields with new values need to be populated.</p>
0505       */
0506         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails ProposedDetails;
0507     }
0508 
0509     /** This class contains result of the updateStudent operation. */
0510     public static final class PXSTUpdateStudentResult
0511     {
0512         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentVersionMismatchError VersionMismatchErrorMessage;
0513         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
0514         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0515     /** <p>Details of an instance after successfull update. Mostly the same as the details passed in, but may have some autogenerated fields populated or updated.</p>
0516       */
0517         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentDetails UpdatedDetails;
0518     }
0519 
0520     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentInput enterprise data structure and
0521       * PXSTUpdateStudentInput string based proxy structure.
0522       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0523     public static final class TRSTUpdateStudentInput
0524     {
0525         private TRSTUpdateStudentInput ()
0526         {
0527         }
0528 
0529         /** This method converts string based operation input structure to the enterprise operation input structure. */
0530         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentInput fromProxyPXSTUpdateStudentInput pProxythrows DataTypeFieldValidationException
0531         {
0532             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentInput();
0533             try
0534             {
0535                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.fromProxypProxy.ProposedDetails));
0536             }
0537             catch (DataTypeValidationException e)
0538             {
0539                 throw new DataTypeFieldValidationException("ProposedDetails", e);
0540             }
0541             return lStruct;
0542         }
0543     }
0544 
0545     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentResult enterprise data structure and
0546       * PXSTUpdateStudentResult string based proxy structure.
0547       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0548     public static final class TRSTUpdateStudentResult
0549     {
0550         private TRSTUpdateStudentResult ()
0551         {
0552         }
0553 
0554         /** This method converts enterprise data structure to the string based proxy structure. */
0555         public static PXSTUpdateStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateStudentResult pStruct)
0556         {
0557             PXSTUpdateStudentResult lProxy = new PXSTUpdateStudentResult();
0558             lProxy.VersionMismatchErrorMessage = TRMOStudentVersionMismatchError.toProxy(pStruct.getVersionMismatchError());
0559             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
0560             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0561             lProxy.UpdatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentDetails.toProxypStruct.getUpdatedDetails());
0562             return lProxy;
0563         }
0564     }
0565 
0566     /** Updates existing instance of Student in the domain.
0567       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0568       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0569       @exception BSException re-thrown from enteprise service component */
0570     public ADBSDataManagement.PXSTUpdateStudentResult updateStudentADBSDataManagement.PXSTUpdateStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
0571     {
0572         Context lContext = new InitialContext();
0573         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0574         return TRSTUpdateStudentResult.toProxy(lService.updateStudent(TRSTUpdateStudentInput.fromProxy(pInput)));
0575     }
0576 
0577     /** This class contains an input to the getCourse operation */
0578     public static final class PXSTGetCourseInput
0579     {
0580     /** <p>The unique key referring to the instance of Course to be retrieved.</p>
0581       */
0582         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey CourseKey;
0583     }
0584 
0585     /** This class contains result of the getCourse operation. */
0586     public static final class PXSTGetCourseResult
0587     {
0588         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
0589         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0590     /** <p>Details of a particuar Course found in the domain.</p>
0591       */
0592         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails Course;
0593     }
0594 
0595     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseInput enterprise data structure and
0596       * PXSTGetCourseInput string based proxy structure.
0597       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0598     public static final class TRSTGetCourseInput
0599     {
0600         private TRSTGetCourseInput ()
0601         {
0602         }
0603 
0604         /** This method converts string based operation input structure to the enterprise operation input structure. */
0605         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseInput fromProxyPXSTGetCourseInput pProxythrows DataTypeFieldValidationException
0606         {
0607             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseInput();
0608             try
0609             {
0610                 lStruct.setCourseKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxypProxy.CourseKey));
0611             }
0612             catch (DataTypeValidationException e)
0613             {
0614                 throw new DataTypeFieldValidationException("CourseKey", e);
0615             }
0616             return lStruct;
0617         }
0618     }
0619 
0620     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseResult enterprise data structure and
0621       * PXSTGetCourseResult string based proxy structure.
0622       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0623     public static final class TRSTGetCourseResult
0624     {
0625         private TRSTGetCourseResult ()
0626         {
0627         }
0628 
0629         /** This method converts enterprise data structure to the string based proxy structure. */
0630         public static PXSTGetCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetCourseResult pStruct)
0631         {
0632             PXSTGetCourseResult lProxy = new PXSTGetCourseResult();
0633             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
0634             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0635             lProxy.Course = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxypStruct.getCourse());
0636             return lProxy;
0637         }
0638     }
0639 
0640     /** Retrieves details of a particular Course instance from the domain. Instance is identified by key structure.
0641       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0642       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0643       @exception BSException re-thrown from enteprise service component */
0644     public ADBSDataManagement.PXSTGetCourseResult getCourseADBSDataManagement.PXSTGetCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
0645     {
0646         Context lContext = new InitialContext();
0647         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0648         return TRSTGetCourseResult.toProxy(lService.getCourse(TRSTGetCourseInput.fromProxy(pInput)));
0649     }
0650 
0651     /** This class contains an input to the createCourse operation */
0652     public static final class PXSTCreateCourseInput
0653     {
0654     /** <p>Proposed details of the new instance of the Course in the domain.</p>
0655       */
0656         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails ProposedDetails;
0657     }
0658 
0659     /** This class contains result of the createCourse operation. */
0660     public static final class PXSTCreateCourseResult
0661     {
0662         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
0663         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseCreationDuplicateKeyError DuplicateKeyErrorMessage;
0664         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0665     /** <p>Details of an instance after successfull creation. Mostly the same as the details passed in, but will have some autogenerated fields populated.</p>
0666       */
0667         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails CreatedDetails;
0668     }
0669 
0670     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseInput enterprise data structure and
0671       * PXSTCreateCourseInput string based proxy structure.
0672       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0673     public static final class TRSTCreateCourseInput
0674     {
0675         private TRSTCreateCourseInput ()
0676         {
0677         }
0678 
0679         /** This method converts string based operation input structure to the enterprise operation input structure. */
0680         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseInput fromProxyPXSTCreateCourseInput pProxythrows DataTypeFieldValidationException
0681         {
0682             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseInput();
0683             try
0684             {
0685                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.fromProxypProxy.ProposedDetails));
0686             }
0687             catch (DataTypeValidationException e)
0688             {
0689                 throw new DataTypeFieldValidationException("ProposedDetails", e);
0690             }
0691             return lStruct;
0692         }
0693     }
0694 
0695     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseResult enterprise data structure and
0696       * PXSTCreateCourseResult string based proxy structure.
0697       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0698     public static final class TRSTCreateCourseResult
0699     {
0700         private TRSTCreateCourseResult ()
0701         {
0702         }
0703 
0704         /** This method converts enterprise data structure to the string based proxy structure. */
0705         public static PXSTCreateCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateCourseResult pStruct)
0706         {
0707             PXSTCreateCourseResult lProxy = new PXSTCreateCourseResult();
0708             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
0709             lProxy.DuplicateKeyErrorMessage = TRMOCourseCreationDuplicateKeyError.toProxy(pStruct.getDuplicateKeyError());
0710             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0711             lProxy.CreatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxypStruct.getCreatedDetails());
0712             return lProxy;
0713         }
0714     }
0715 
0716     /** Creates new instance of Course in the domain.
0717       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0718       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0719       @exception BSException re-thrown from enteprise service component */
0720     public ADBSDataManagement.PXSTCreateCourseResult createCourseADBSDataManagement.PXSTCreateCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
0721     {
0722         Context lContext = new InitialContext();
0723         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0724         return TRSTCreateCourseResult.toProxy(lService.createCourse(TRSTCreateCourseInput.fromProxy(pInput)));
0725     }
0726 
0727     /** This class contains an input to the deleteCourse operation */
0728     public static final class PXSTDeleteCourseInput
0729     {
0730     /** <p>The unique key referring to the instance of Course to be deleted.</p>
0731       */
0732         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey CourseKey;
0733     }
0734 
0735     /** This class contains result of the deleteCourse operation. */
0736     public static final class PXSTDeleteCourseResult
0737     {
0738         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
0739         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0740     }
0741 
0742     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseInput enterprise data structure and
0743       * PXSTDeleteCourseInput string based proxy structure.
0744       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0745     public static final class TRSTDeleteCourseInput
0746     {
0747         private TRSTDeleteCourseInput ()
0748         {
0749         }
0750 
0751         /** This method converts string based operation input structure to the enterprise operation input structure. */
0752         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseInput fromProxyPXSTDeleteCourseInput pProxythrows DataTypeFieldValidationException
0753         {
0754             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseInput();
0755             try
0756             {
0757                 lStruct.setCourseKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxypProxy.CourseKey));
0758             }
0759             catch (DataTypeValidationException e)
0760             {
0761                 throw new DataTypeFieldValidationException("CourseKey", e);
0762             }
0763             return lStruct;
0764         }
0765     }
0766 
0767     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseResult enterprise data structure and
0768       * PXSTDeleteCourseResult string based proxy structure.
0769       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0770     public static final class TRSTDeleteCourseResult
0771     {
0772         private TRSTDeleteCourseResult ()
0773         {
0774         }
0775 
0776         /** This method converts enterprise data structure to the string based proxy structure. */
0777         public static PXSTDeleteCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteCourseResult pStruct)
0778         {
0779             PXSTDeleteCourseResult lProxy = new PXSTDeleteCourseResult();
0780             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
0781             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0782             return lProxy;
0783         }
0784     }
0785 
0786     /** Deletes existing instance of Course in the domain.
0787       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0788       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0789       @exception BSException re-thrown from enteprise service component */
0790     public ADBSDataManagement.PXSTDeleteCourseResult deleteCourseADBSDataManagement.PXSTDeleteCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
0791     {
0792         Context lContext = new InitialContext();
0793         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0794         return TRSTDeleteCourseResult.toProxy(lService.deleteCourse(TRSTDeleteCourseInput.fromProxy(pInput)));
0795     }
0796 
0797     /** This class contains an input to the getAllCoursesCount operation */
0798     public static final class PXSTGetAllCoursesCountInput
0799     {
0800     }
0801 
0802     /** This class contains result of the getAllCoursesCount operation. */
0803     public static final class PXSTGetAllCoursesCountResult
0804     {
0805     /** <p>Number of Courses found in the domain.</p>
0806       <p>The range of string values this field can be populated with is governed by the 
0807       {@link com.almamater.types.core.CollectionSize CollectionSize} datatype.</p>
0808       */
0809         public String CoursesCount;
0810     }
0811 
0812     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountInput enterprise data structure and
0813       * PXSTGetAllCoursesCountInput string based proxy structure.
0814       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0815     public static final class TRSTGetAllCoursesCountInput
0816     {
0817         private TRSTGetAllCoursesCountInput ()
0818         {
0819         }
0820 
0821         /** This method converts string based operation input structure to the enterprise operation input structure. */
0822         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountInput fromProxyPXSTGetAllCoursesCountInput pProxythrows DataTypeFieldValidationException
0823         {
0824             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountInput();
0825             return lStruct;
0826         }
0827     }
0828 
0829     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountResult enterprise data structure and
0830       * PXSTGetAllCoursesCountResult string based proxy structure.
0831       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0832     public static final class TRSTGetAllCoursesCountResult
0833     {
0834         private TRSTGetAllCoursesCountResult ()
0835         {
0836         }
0837 
0838         /** This method converts enterprise data structure to the string based proxy structure. */
0839         public static PXSTGetAllCoursesCountResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesCountResult pStruct)
0840         {
0841             PXSTGetAllCoursesCountResult lProxy = new PXSTGetAllCoursesCountResult();
0842             com.almamater.types.core.CollectionSize lCoursesCount = pStruct.getCoursesCount();
0843             if (lCoursesCount != null)
0844                lProxy.CoursesCount = lCoursesCount.toString();
0845             return lProxy;
0846         }
0847     }
0848 
0849     /** Retrieves count of all Courses present in the domain.
0850       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0851       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0852       @exception BSException re-thrown from enteprise service component */
0853     public ADBSDataManagement.PXSTGetAllCoursesCountResult getAllCoursesCountADBSDataManagement.PXSTGetAllCoursesCountInput pInputthrows BSException, DataTypeValidationException, NamingException
0854     {
0855         Context lContext = new InitialContext();
0856         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0857         return TRSTGetAllCoursesCountResult.toProxy(lService.getAllCoursesCount(TRSTGetAllCoursesCountInput.fromProxy(pInput)));
0858     }
0859 
0860     /** This class contains an input to the getAllCourses operation */
0861     public static final class PXSTGetAllCoursesInput
0862     {
0863     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned Courses will be sorted in accordance with these instructions.</p>
0864       <p>The range of string values this field can be populated with is governed by the 
0865       {@link com.almamater.crs.types.system.courses.CourseOrderingInstruction CourseOrderingInstruction} datatype.</p>
0866       */
0867         public String[] OrderingInstructions;
0868     }
0869 
0870     /** This class contains result of the getAllCourses operation. */
0871     public static final class PXSTGetAllCoursesResult
0872     {
0873         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0874     /** <p>Details of all Courses found in the domain.</p>
0875       */
0876         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails[] Courses;
0877     }
0878 
0879     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesInput enterprise data structure and
0880       * PXSTGetAllCoursesInput string based proxy structure.
0881       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0882     public static final class TRSTGetAllCoursesInput
0883     {
0884         private TRSTGetAllCoursesInput ()
0885         {
0886         }
0887 
0888         /** This method converts string based operation input structure to the enterprise operation input structure. */
0889         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesInput fromProxyPXSTGetAllCoursesInput pProxythrows DataTypeFieldValidationException
0890         {
0891             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesInput();
0892             try
0893             {
0894                 if (pProxy.OrderingInstructions != null)
0895                 {
0896                      com.almamater.crs.types.system.courses.CourseOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.CourseOrderingInstruction[pProxy.OrderingInstructions.length];
0897                     for (int i = 0; i < lStructArray.length; i++)
0898                     {
0899                         String lProxyElement = pProxy.OrderingInstructions[i];
0900                         if (lProxyElement != null)
0901                            lStructArray[i= com.almamater.crs.types.system.courses.CourseOrderingInstruction.createFromString(lProxyElement);
0902                     }
0903                     lStruct.setOrderingInstructions(lStructArray);
0904                 }
0905             }
0906             catch (DataTypeValidationException e)
0907             {
0908                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
0909             }
0910             return lStruct;
0911         }
0912     }
0913 
0914     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesResult enterprise data structure and
0915       * PXSTGetAllCoursesResult string based proxy structure.
0916       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0917     public static final class TRSTGetAllCoursesResult
0918     {
0919         private TRSTGetAllCoursesResult ()
0920         {
0921         }
0922 
0923         /** This method converts enterprise data structure to the string based proxy structure. */
0924         public static PXSTGetAllCoursesResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesResult pStruct)
0925         {
0926             PXSTGetAllCoursesResult lProxy = new PXSTGetAllCoursesResult();
0927             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
0928             lProxy.Courses = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxyArraypStruct.getCourses());
0929             return lProxy;
0930         }
0931     }
0932 
0933     /** Retrieves details of all Courses present in the domain.
0934       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
0935       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
0936       @exception BSException re-thrown from enteprise service component */
0937     public ADBSDataManagement.PXSTGetAllCoursesResult getAllCoursesADBSDataManagement.PXSTGetAllCoursesInput pInputthrows BSException, DataTypeValidationException, NamingException
0938     {
0939         Context lContext = new InitialContext();
0940         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
0941         return TRSTGetAllCoursesResult.toProxy(lService.getAllCourses(TRSTGetAllCoursesInput.fromProxy(pInput)));
0942     }
0943 
0944     /** This class contains an input to the getSubsetOfCourses operation */
0945     public static final class PXSTGetSubsetOfCoursesInput
0946     {
0947     /** <p>Zero-based offset from the first entity details to be returned to the beginning of the whole collection of Courses present in domain.</p>
0948       <p>The range of string values this field can be populated with is governed by the 
0949       {@link com.almamater.types.core.CollectionOffset CollectionOffset} datatype.</p>
0950       */
0951         public String FirstRecordOffset;
0952     /** <p>The desired maximum number of detail records to be returned. Note that actual number of details returned might be lower if domain does not have sufficient number of Courses.</p>
0953       <p>The range of string values this field can be populated with is governed by the 
0954       {@link com.almamater.types.core.SubsetSize SubsetSize} datatype.</p>
0955       */
0956         public String RequiredMaxSize;
0957     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned subset of the Courses will be cut out after sorting of the whole set has been done in accordance with these instructions.</p>
0958       <p>The range of string values this field can be populated with is governed by the 
0959       {@link com.almamater.crs.types.system.courses.CourseOrderingInstruction CourseOrderingInstruction} datatype.</p>
0960       */
0961         public String[] OrderingInstructions;
0962     }
0963 
0964     /** This class contains result of the getSubsetOfCourses operation. */
0965     public static final class PXSTGetSubsetOfCoursesResult
0966     {
0967         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
0968     /** <p>Details of all Courses found in the domain starting from specified offset and spanning no more than required maximum number of records.</p>
0969       */
0970         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails[] Courses;
0971     }
0972 
0973     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesInput enterprise data structure and
0974       * PXSTGetSubsetOfCoursesInput string based proxy structure.
0975       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
0976     public static final class TRSTGetSubsetOfCoursesInput
0977     {
0978         private TRSTGetSubsetOfCoursesInput ()
0979         {
0980         }
0981 
0982         /** This method converts string based operation input structure to the enterprise operation input structure. */
0983         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesInput fromProxyPXSTGetSubsetOfCoursesInput pProxythrows DataTypeFieldValidationException
0984         {
0985             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesInput();
0986             try
0987             {
0988                 lStruct.setFirstRecordOffset(com.almamater.types.core.CollectionOffset.createFromString(pProxy.FirstRecordOffset));
0989             }
0990             catch (DataTypeValidationException e)
0991             {
0992                 throw new DataTypeFieldValidationException("FirstRecordOffset", e);
0993             }
0994             try
0995             {
0996                 lStruct.setRequiredMaxSize(com.almamater.types.core.SubsetSize.createFromString(pProxy.RequiredMaxSize));
0997             }
0998             catch (DataTypeValidationException e)
0999             {
1000                 throw new DataTypeFieldValidationException("RequiredMaxSize", e);
1001             }
1002             try
1003             {
1004                 if (pProxy.OrderingInstructions != null)
1005                 {
1006                      com.almamater.crs.types.system.courses.CourseOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.CourseOrderingInstruction[pProxy.OrderingInstructions.length];
1007                     for (int i = 0; i < lStructArray.length; i++)
1008                     {
1009                         String lProxyElement = pProxy.OrderingInstructions[i];
1010                         if (lProxyElement != null)
1011                            lStructArray[i= com.almamater.crs.types.system.courses.CourseOrderingInstruction.createFromString(lProxyElement);
1012                     }
1013                     lStruct.setOrderingInstructions(lStructArray);
1014                 }
1015             }
1016             catch (DataTypeValidationException e)
1017             {
1018                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
1019             }
1020             return lStruct;
1021         }
1022     }
1023 
1024     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesResult enterprise data structure and
1025       * PXSTGetSubsetOfCoursesResult string based proxy structure.
1026       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1027     public static final class TRSTGetSubsetOfCoursesResult
1028     {
1029         private TRSTGetSubsetOfCoursesResult ()
1030         {
1031         }
1032 
1033         /** This method converts enterprise data structure to the string based proxy structure. */
1034         public static PXSTGetSubsetOfCoursesResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfCoursesResult pStruct)
1035         {
1036             PXSTGetSubsetOfCoursesResult lProxy = new PXSTGetSubsetOfCoursesResult();
1037             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1038             lProxy.Courses = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxyArraypStruct.getCourses());
1039             return lProxy;
1040         }
1041     }
1042 
1043     /** Retrieves details of the required subset of Courses present in the domain.
1044       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1045       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1046       @exception BSException re-thrown from enteprise service component */
1047     public ADBSDataManagement.PXSTGetSubsetOfCoursesResult getSubsetOfCoursesADBSDataManagement.PXSTGetSubsetOfCoursesInput pInputthrows BSException, DataTypeValidationException, NamingException
1048     {
1049         Context lContext = new InitialContext();
1050         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1051         return TRSTGetSubsetOfCoursesResult.toProxy(lService.getSubsetOfCourses(TRSTGetSubsetOfCoursesInput.fromProxy(pInput)));
1052     }
1053 
1054     /** This class contains an input to the updateCourse operation */
1055     public static final class PXSTUpdateCourseInput
1056     {
1057     /** <p>Proposed new details of the existing instance of the Course. Only identifier fields and fields with new values need to be populated.</p>
1058       */
1059         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails ProposedDetails;
1060     }
1061 
1062     /** This class contains result of the updateCourse operation. */
1063     public static final class PXSTUpdateCourseResult
1064     {
1065         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseVersionMismatchError VersionMismatchErrorMessage;
1066         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
1067         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1068         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1069     /** <p>Details of an instance after successfull update. Mostly the same as the details passed in, but may have some autogenerated fields populated or updated.</p>
1070       */
1071         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails UpdatedDetails;
1072     }
1073 
1074     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseInput enterprise data structure and
1075       * PXSTUpdateCourseInput string based proxy structure.
1076       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1077     public static final class TRSTUpdateCourseInput
1078     {
1079         private TRSTUpdateCourseInput ()
1080         {
1081         }
1082 
1083         /** This method converts string based operation input structure to the enterprise operation input structure. */
1084         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseInput fromProxyPXSTUpdateCourseInput pProxythrows DataTypeFieldValidationException
1085         {
1086             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseInput();
1087             try
1088             {
1089                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.fromProxypProxy.ProposedDetails));
1090             }
1091             catch (DataTypeValidationException e)
1092             {
1093                 throw new DataTypeFieldValidationException("ProposedDetails", e);
1094             }
1095             return lStruct;
1096         }
1097     }
1098 
1099     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseResult enterprise data structure and
1100       * PXSTUpdateCourseResult string based proxy structure.
1101       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1102     public static final class TRSTUpdateCourseResult
1103     {
1104         private TRSTUpdateCourseResult ()
1105         {
1106         }
1107 
1108         /** This method converts enterprise data structure to the string based proxy structure. */
1109         public static PXSTUpdateCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateCourseResult pStruct)
1110         {
1111             PXSTUpdateCourseResult lProxy = new PXSTUpdateCourseResult();
1112             lProxy.VersionMismatchErrorMessage = TRMOCourseVersionMismatchError.toProxy(pStruct.getVersionMismatchError());
1113             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
1114             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1115             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1116             lProxy.UpdatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxypStruct.getUpdatedDetails());
1117             return lProxy;
1118         }
1119     }
1120 
1121     /** Updates existing instance of Course in the domain.
1122       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1123       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1124       @exception BSException re-thrown from enteprise service component */
1125     public ADBSDataManagement.PXSTUpdateCourseResult updateCourseADBSDataManagement.PXSTUpdateCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
1126     {
1127         Context lContext = new InitialContext();
1128         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1129         return TRSTUpdateCourseResult.toProxy(lService.updateCourse(TRSTUpdateCourseInput.fromProxy(pInput)));
1130     }
1131 
1132     /** This class contains an input to the getTeacher operation */
1133     public static final class PXSTGetTeacherInput
1134     {
1135     /** <p>The unique key referring to the instance of Teacher to be retrieved.</p>
1136       */
1137         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherKey TeacherKey;
1138     }
1139 
1140     /** This class contains result of the getTeacher operation. */
1141     public static final class PXSTGetTeacherResult
1142     {
1143         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1144         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1145     /** <p>Details of a particuar Teacher found in the domain.</p>
1146       */
1147         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails Teacher;
1148     }
1149 
1150     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherInput enterprise data structure and
1151       * PXSTGetTeacherInput string based proxy structure.
1152       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1153     public static final class TRSTGetTeacherInput
1154     {
1155         private TRSTGetTeacherInput ()
1156         {
1157         }
1158 
1159         /** This method converts string based operation input structure to the enterprise operation input structure. */
1160         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherInput fromProxyPXSTGetTeacherInput pProxythrows DataTypeFieldValidationException
1161         {
1162             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherInput();
1163             try
1164             {
1165                 lStruct.setTeacherKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherKey.fromProxypProxy.TeacherKey));
1166             }
1167             catch (DataTypeValidationException e)
1168             {
1169                 throw new DataTypeFieldValidationException("TeacherKey", e);
1170             }
1171             return lStruct;
1172         }
1173     }
1174 
1175     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherResult enterprise data structure and
1176       * PXSTGetTeacherResult string based proxy structure.
1177       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1178     public static final class TRSTGetTeacherResult
1179     {
1180         private TRSTGetTeacherResult ()
1181         {
1182         }
1183 
1184         /** This method converts enterprise data structure to the string based proxy structure. */
1185         public static PXSTGetTeacherResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetTeacherResult pStruct)
1186         {
1187             PXSTGetTeacherResult lProxy = new PXSTGetTeacherResult();
1188             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1189             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1190             lProxy.Teacher = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxypStruct.getTeacher());
1191             return lProxy;
1192         }
1193     }
1194 
1195     /** Retrieves details of a particular Teacher instance from the domain. Instance is identified by key structure.
1196       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1197       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1198       @exception BSException re-thrown from enteprise service component */
1199     public ADBSDataManagement.PXSTGetTeacherResult getTeacherADBSDataManagement.PXSTGetTeacherInput pInputthrows BSException, DataTypeValidationException, NamingException
1200     {
1201         Context lContext = new InitialContext();
1202         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1203         return TRSTGetTeacherResult.toProxy(lService.getTeacher(TRSTGetTeacherInput.fromProxy(pInput)));
1204     }
1205 
1206     /** This class contains an input to the createTeacher operation */
1207     public static final class PXSTCreateTeacherInput
1208     {
1209     /** <p>Proposed details of the new instance of the Teacher in the domain.</p>
1210       */
1211         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails ProposedDetails;
1212     }
1213 
1214     /** This class contains result of the createTeacher operation. */
1215     public static final class PXSTCreateTeacherResult
1216     {
1217         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1218     /** <p>Details of an instance after successfull creation. Mostly the same as the details passed in, but will have some autogenerated fields populated.</p>
1219       */
1220         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails CreatedDetails;
1221     }
1222 
1223     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherInput enterprise data structure and
1224       * PXSTCreateTeacherInput string based proxy structure.
1225       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1226     public static final class TRSTCreateTeacherInput
1227     {
1228         private TRSTCreateTeacherInput ()
1229         {
1230         }
1231 
1232         /** This method converts string based operation input structure to the enterprise operation input structure. */
1233         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherInput fromProxyPXSTCreateTeacherInput pProxythrows DataTypeFieldValidationException
1234         {
1235             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherInput();
1236             try
1237             {
1238                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.fromProxypProxy.ProposedDetails));
1239             }
1240             catch (DataTypeValidationException e)
1241             {
1242                 throw new DataTypeFieldValidationException("ProposedDetails", e);
1243             }
1244             return lStruct;
1245         }
1246     }
1247 
1248     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherResult enterprise data structure and
1249       * PXSTCreateTeacherResult string based proxy structure.
1250       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1251     public static final class TRSTCreateTeacherResult
1252     {
1253         private TRSTCreateTeacherResult ()
1254         {
1255         }
1256 
1257         /** This method converts enterprise data structure to the string based proxy structure. */
1258         public static PXSTCreateTeacherResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STCreateTeacherResult pStruct)
1259         {
1260             PXSTCreateTeacherResult lProxy = new PXSTCreateTeacherResult();
1261             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1262             lProxy.CreatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxypStruct.getCreatedDetails());
1263             return lProxy;
1264         }
1265     }
1266 
1267     /** Creates new instance of Teacher in the domain.
1268       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1269       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1270       @exception BSException re-thrown from enteprise service component */
1271     public ADBSDataManagement.PXSTCreateTeacherResult createTeacherADBSDataManagement.PXSTCreateTeacherInput pInputthrows BSException, DataTypeValidationException, NamingException
1272     {
1273         Context lContext = new InitialContext();
1274         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1275         return TRSTCreateTeacherResult.toProxy(lService.createTeacher(TRSTCreateTeacherInput.fromProxy(pInput)));
1276     }
1277 
1278     /** This class contains an input to the deleteTeacher operation */
1279     public static final class PXSTDeleteTeacherInput
1280     {
1281     /** <p>The unique key referring to the instance of Teacher to be deleted.</p>
1282       */
1283         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherKey TeacherKey;
1284     }
1285 
1286     /** This class contains result of the deleteTeacher operation. */
1287     public static final class PXSTDeleteTeacherResult
1288     {
1289         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1290         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1291     }
1292 
1293     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherInput enterprise data structure and
1294       * PXSTDeleteTeacherInput string based proxy structure.
1295       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1296     public static final class TRSTDeleteTeacherInput
1297     {
1298         private TRSTDeleteTeacherInput ()
1299         {
1300         }
1301 
1302         /** This method converts string based operation input structure to the enterprise operation input structure. */
1303         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherInput fromProxyPXSTDeleteTeacherInput pProxythrows DataTypeFieldValidationException
1304         {
1305             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherInput();
1306             try
1307             {
1308                 lStruct.setTeacherKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherKey.fromProxypProxy.TeacherKey));
1309             }
1310             catch (DataTypeValidationException e)
1311             {
1312                 throw new DataTypeFieldValidationException("TeacherKey", e);
1313             }
1314             return lStruct;
1315         }
1316     }
1317 
1318     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherResult enterprise data structure and
1319       * PXSTDeleteTeacherResult string based proxy structure.
1320       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1321     public static final class TRSTDeleteTeacherResult
1322     {
1323         private TRSTDeleteTeacherResult ()
1324         {
1325         }
1326 
1327         /** This method converts enterprise data structure to the string based proxy structure. */
1328         public static PXSTDeleteTeacherResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STDeleteTeacherResult pStruct)
1329         {
1330             PXSTDeleteTeacherResult lProxy = new PXSTDeleteTeacherResult();
1331             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1332             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1333             return lProxy;
1334         }
1335     }
1336 
1337     /** Deletes existing instance of Teacher in the domain.
1338       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1339       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1340       @exception BSException re-thrown from enteprise service component */
1341     public ADBSDataManagement.PXSTDeleteTeacherResult deleteTeacherADBSDataManagement.PXSTDeleteTeacherInput pInputthrows BSException, DataTypeValidationException, NamingException
1342     {
1343         Context lContext = new InitialContext();
1344         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1345         return TRSTDeleteTeacherResult.toProxy(lService.deleteTeacher(TRSTDeleteTeacherInput.fromProxy(pInput)));
1346     }
1347 
1348     /** This class contains an input to the getAllTeachersCount operation */
1349     public static final class PXSTGetAllTeachersCountInput
1350     {
1351     }
1352 
1353     /** This class contains result of the getAllTeachersCount operation. */
1354     public static final class PXSTGetAllTeachersCountResult
1355     {
1356     /** <p>Number of Teachers found in the domain.</p>
1357       <p>The range of string values this field can be populated with is governed by the 
1358       {@link com.almamater.types.core.CollectionSize CollectionSize} datatype.</p>
1359       */
1360         public String TeachersCount;
1361     }
1362 
1363     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountInput enterprise data structure and
1364       * PXSTGetAllTeachersCountInput string based proxy structure.
1365       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1366     public static final class TRSTGetAllTeachersCountInput
1367     {
1368         private TRSTGetAllTeachersCountInput ()
1369         {
1370         }
1371 
1372         /** This method converts string based operation input structure to the enterprise operation input structure. */
1373         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountInput fromProxyPXSTGetAllTeachersCountInput pProxythrows DataTypeFieldValidationException
1374         {
1375             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountInput();
1376             return lStruct;
1377         }
1378     }
1379 
1380     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountResult enterprise data structure and
1381       * PXSTGetAllTeachersCountResult string based proxy structure.
1382       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1383     public static final class TRSTGetAllTeachersCountResult
1384     {
1385         private TRSTGetAllTeachersCountResult ()
1386         {
1387         }
1388 
1389         /** This method converts enterprise data structure to the string based proxy structure. */
1390         public static PXSTGetAllTeachersCountResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersCountResult pStruct)
1391         {
1392             PXSTGetAllTeachersCountResult lProxy = new PXSTGetAllTeachersCountResult();
1393             com.almamater.types.core.CollectionSize lTeachersCount = pStruct.getTeachersCount();
1394             if (lTeachersCount != null)
1395                lProxy.TeachersCount = lTeachersCount.toString();
1396             return lProxy;
1397         }
1398     }
1399 
1400     /** Retrieves count of all Teachers present in the domain.
1401       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1402       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1403       @exception BSException re-thrown from enteprise service component */
1404     public ADBSDataManagement.PXSTGetAllTeachersCountResult getAllTeachersCountADBSDataManagement.PXSTGetAllTeachersCountInput pInputthrows BSException, DataTypeValidationException, NamingException
1405     {
1406         Context lContext = new InitialContext();
1407         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1408         return TRSTGetAllTeachersCountResult.toProxy(lService.getAllTeachersCount(TRSTGetAllTeachersCountInput.fromProxy(pInput)));
1409     }
1410 
1411     /** This class contains an input to the getAllTeachers operation */
1412     public static final class PXSTGetAllTeachersInput
1413     {
1414     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned Teachers will be sorted in accordance with these instructions.</p>
1415       <p>The range of string values this field can be populated with is governed by the 
1416       {@link com.almamater.crs.types.system.courses.TeacherOrderingInstruction TeacherOrderingInstruction} datatype.</p>
1417       */
1418         public String[] OrderingInstructions;
1419     }
1420 
1421     /** This class contains result of the getAllTeachers operation. */
1422     public static final class PXSTGetAllTeachersResult
1423     {
1424         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1425     /** <p>Details of all Teachers found in the domain.</p>
1426       */
1427         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails[] Teachers;
1428     }
1429 
1430     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersInput enterprise data structure and
1431       * PXSTGetAllTeachersInput string based proxy structure.
1432       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1433     public static final class TRSTGetAllTeachersInput
1434     {
1435         private TRSTGetAllTeachersInput ()
1436         {
1437         }
1438 
1439         /** This method converts string based operation input structure to the enterprise operation input structure. */
1440         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersInput fromProxyPXSTGetAllTeachersInput pProxythrows DataTypeFieldValidationException
1441         {
1442             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersInput();
1443             try
1444             {
1445                 if (pProxy.OrderingInstructions != null)
1446                 {
1447                      com.almamater.crs.types.system.courses.TeacherOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.TeacherOrderingInstruction[pProxy.OrderingInstructions.length];
1448                     for (int i = 0; i < lStructArray.length; i++)
1449                     {
1450                         String lProxyElement = pProxy.OrderingInstructions[i];
1451                         if (lProxyElement != null)
1452                            lStructArray[i= com.almamater.crs.types.system.courses.TeacherOrderingInstruction.createFromString(lProxyElement);
1453                     }
1454                     lStruct.setOrderingInstructions(lStructArray);
1455                 }
1456             }
1457             catch (DataTypeValidationException e)
1458             {
1459                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
1460             }
1461             return lStruct;
1462         }
1463     }
1464 
1465     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersResult enterprise data structure and
1466       * PXSTGetAllTeachersResult string based proxy structure.
1467       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1468     public static final class TRSTGetAllTeachersResult
1469     {
1470         private TRSTGetAllTeachersResult ()
1471         {
1472         }
1473 
1474         /** This method converts enterprise data structure to the string based proxy structure. */
1475         public static PXSTGetAllTeachersResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllTeachersResult pStruct)
1476         {
1477             PXSTGetAllTeachersResult lProxy = new PXSTGetAllTeachersResult();
1478             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1479             lProxy.Teachers = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxyArraypStruct.getTeachers());
1480             return lProxy;
1481         }
1482     }
1483 
1484     /** Retrieves details of all Teachers present in the domain.
1485       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1486       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1487       @exception BSException re-thrown from enteprise service component */
1488     public ADBSDataManagement.PXSTGetAllTeachersResult getAllTeachersADBSDataManagement.PXSTGetAllTeachersInput pInputthrows BSException, DataTypeValidationException, NamingException
1489     {
1490         Context lContext = new InitialContext();
1491         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1492         return TRSTGetAllTeachersResult.toProxy(lService.getAllTeachers(TRSTGetAllTeachersInput.fromProxy(pInput)));
1493     }
1494 
1495     /** This class contains an input to the getSubsetOfTeachers operation */
1496     public static final class PXSTGetSubsetOfTeachersInput
1497     {
1498     /** <p>Zero-based offset from the first entity details to be returned to the beginning of the whole collection of Teachers present in domain.</p>
1499       <p>The range of string values this field can be populated with is governed by the 
1500       {@link com.almamater.types.core.CollectionOffset CollectionOffset} datatype.</p>
1501       */
1502         public String FirstRecordOffset;
1503     /** <p>The desired maximum number of detail records to be returned. Note that actual number of details returned might be lower if domain does not have sufficient number of Teachers.</p>
1504       <p>The range of string values this field can be populated with is governed by the 
1505       {@link com.almamater.types.core.SubsetSize SubsetSize} datatype.</p>
1506       */
1507         public String RequiredMaxSize;
1508     /** <p>Array of zero or more ordering instructions (weight of the instruction is diminising towards the end of the array). Returned subset of the Teachers will be cut out after sorting of the whole set has been done in accordance with these instructions.</p>
1509       <p>The range of string values this field can be populated with is governed by the 
1510       {@link com.almamater.crs.types.system.courses.TeacherOrderingInstruction TeacherOrderingInstruction} datatype.</p>
1511       */
1512         public String[] OrderingInstructions;
1513     }
1514 
1515     /** This class contains result of the getSubsetOfTeachers operation. */
1516     public static final class PXSTGetSubsetOfTeachersResult
1517     {
1518         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1519     /** <p>Details of all Teachers found in the domain starting from specified offset and spanning no more than required maximum number of records.</p>
1520       */
1521         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails[] Teachers;
1522     }
1523 
1524     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersInput enterprise data structure and
1525       * PXSTGetSubsetOfTeachersInput string based proxy structure.
1526       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1527     public static final class TRSTGetSubsetOfTeachersInput
1528     {
1529         private TRSTGetSubsetOfTeachersInput ()
1530         {
1531         }
1532 
1533         /** This method converts string based operation input structure to the enterprise operation input structure. */
1534         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersInput fromProxyPXSTGetSubsetOfTeachersInput pProxythrows DataTypeFieldValidationException
1535         {
1536             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersInput();
1537             try
1538             {
1539                 lStruct.setFirstRecordOffset(com.almamater.types.core.CollectionOffset.createFromString(pProxy.FirstRecordOffset));
1540             }
1541             catch (DataTypeValidationException e)
1542             {
1543                 throw new DataTypeFieldValidationException("FirstRecordOffset", e);
1544             }
1545             try
1546             {
1547                 lStruct.setRequiredMaxSize(com.almamater.types.core.SubsetSize.createFromString(pProxy.RequiredMaxSize));
1548             }
1549             catch (DataTypeValidationException e)
1550             {
1551                 throw new DataTypeFieldValidationException("RequiredMaxSize", e);
1552             }
1553             try
1554             {
1555                 if (pProxy.OrderingInstructions != null)
1556                 {
1557                      com.almamater.crs.types.system.courses.TeacherOrderingInstruction[] lStructArray = new com.almamater.crs.types.system.courses.TeacherOrderingInstruction[pProxy.OrderingInstructions.length];
1558                     for (int i = 0; i < lStructArray.length; i++)
1559                     {
1560                         String lProxyElement = pProxy.OrderingInstructions[i];
1561                         if (lProxyElement != null)
1562                            lStructArray[i= com.almamater.crs.types.system.courses.TeacherOrderingInstruction.createFromString(lProxyElement);
1563                     }
1564                     lStruct.setOrderingInstructions(lStructArray);
1565                 }
1566             }
1567             catch (DataTypeValidationException e)
1568             {
1569                 throw new DataTypeFieldValidationException("OrderingInstructions", e);
1570             }
1571             return lStruct;
1572         }
1573     }
1574 
1575     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersResult enterprise data structure and
1576       * PXSTGetSubsetOfTeachersResult string based proxy structure.
1577       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1578     public static final class TRSTGetSubsetOfTeachersResult
1579     {
1580         private TRSTGetSubsetOfTeachersResult ()
1581         {
1582         }
1583 
1584         /** This method converts enterprise data structure to the string based proxy structure. */
1585         public static PXSTGetSubsetOfTeachersResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetSubsetOfTeachersResult pStruct)
1586         {
1587             PXSTGetSubsetOfTeachersResult lProxy = new PXSTGetSubsetOfTeachersResult();
1588             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1589             lProxy.Teachers = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxyArraypStruct.getTeachers());
1590             return lProxy;
1591         }
1592     }
1593 
1594     /** Retrieves details of the required subset of Teachers present in the domain.
1595       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1596       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1597       @exception BSException re-thrown from enteprise service component */
1598     public ADBSDataManagement.PXSTGetSubsetOfTeachersResult getSubsetOfTeachersADBSDataManagement.PXSTGetSubsetOfTeachersInput pInputthrows BSException, DataTypeValidationException, NamingException
1599     {
1600         Context lContext = new InitialContext();
1601         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1602         return TRSTGetSubsetOfTeachersResult.toProxy(lService.getSubsetOfTeachers(TRSTGetSubsetOfTeachersInput.fromProxy(pInput)));
1603     }
1604 
1605     /** This class contains an input to the updateTeacher operation */
1606     public static final class PXSTUpdateTeacherInput
1607     {
1608     /** <p>Proposed new details of the existing instance of the Teacher. Only identifier fields and fields with new values need to be populated.</p>
1609       */
1610         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails ProposedDetails;
1611     }
1612 
1613     /** This class contains result of the updateTeacher operation. */
1614     public static final class PXSTUpdateTeacherResult
1615     {
1616         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherVersionMismatchError VersionMismatchErrorMessage;
1617         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1618         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1619     /** <p>Details of an instance after successfull update. Mostly the same as the details passed in, but may have some autogenerated fields populated or updated.</p>
1620       */
1621         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails UpdatedDetails;
1622     }
1623 
1624     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherInput enterprise data structure and
1625       * PXSTUpdateTeacherInput string based proxy structure.
1626       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1627     public static final class TRSTUpdateTeacherInput
1628     {
1629         private TRSTUpdateTeacherInput ()
1630         {
1631         }
1632 
1633         /** This method converts string based operation input structure to the enterprise operation input structure. */
1634         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherInput fromProxyPXSTUpdateTeacherInput pProxythrows DataTypeFieldValidationException
1635         {
1636             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherInput();
1637             try
1638             {
1639                 lStruct.setProposedDetails(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.fromProxypProxy.ProposedDetails));
1640             }
1641             catch (DataTypeValidationException e)
1642             {
1643                 throw new DataTypeFieldValidationException("ProposedDetails", e);
1644             }
1645             return lStruct;
1646         }
1647     }
1648 
1649     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherResult enterprise data structure and
1650       * PXSTUpdateTeacherResult string based proxy structure.
1651       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1652     public static final class TRSTUpdateTeacherResult
1653     {
1654         private TRSTUpdateTeacherResult ()
1655         {
1656         }
1657 
1658         /** This method converts enterprise data structure to the string based proxy structure. */
1659         public static PXSTUpdateTeacherResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STUpdateTeacherResult pStruct)
1660         {
1661             PXSTUpdateTeacherResult lProxy = new PXSTUpdateTeacherResult();
1662             lProxy.VersionMismatchErrorMessage = TRMOTeacherVersionMismatchError.toProxy(pStruct.getVersionMismatchError());
1663             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1664             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1665             lProxy.UpdatedDetails = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxypStruct.getUpdatedDetails());
1666             return lProxy;
1667         }
1668     }
1669 
1670     /** Updates existing instance of Teacher in the domain.
1671       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1672       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1673       @exception BSException re-thrown from enteprise service component */
1674     public ADBSDataManagement.PXSTUpdateTeacherResult updateTeacherADBSDataManagement.PXSTUpdateTeacherInput pInputthrows BSException, DataTypeValidationException, NamingException
1675     {
1676         Context lContext = new InitialContext();
1677         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1678         return TRSTUpdateTeacherResult.toProxy(lService.updateTeacher(TRSTUpdateTeacherInput.fromProxy(pInput)));
1679     }
1680 
1681     /** This class contains an input to the addLecturersToCourse operation */
1682     public static final class PXSTAddLecturersToCourseInput
1683     {
1684     /** <p>The unique key identifying the Course to be edited.</p>
1685       */
1686         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey CourseKey;
1687     /** <p>The array of unique keys identifying Lecturers to be added.</p>
1688       */
1689         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherKey[] LecturerKeys;
1690     }
1691 
1692     /** This class contains result of the addLecturersToCourse operation. */
1693     public static final class PXSTAddLecturersToCourseResult
1694     {
1695         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
1696         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1697         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1698     }
1699 
1700     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseInput enterprise data structure and
1701       * PXSTAddLecturersToCourseInput string based proxy structure.
1702       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1703     public static final class TRSTAddLecturersToCourseInput
1704     {
1705         private TRSTAddLecturersToCourseInput ()
1706         {
1707         }
1708 
1709         /** This method converts string based operation input structure to the enterprise operation input structure. */
1710         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseInput fromProxyPXSTAddLecturersToCourseInput pProxythrows DataTypeFieldValidationException
1711         {
1712             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseInput();
1713             try
1714             {
1715                 lStruct.setCourseKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxypProxy.CourseKey));
1716             }
1717             catch (DataTypeValidationException e)
1718             {
1719                 throw new DataTypeFieldValidationException("CourseKey", e);
1720             }
1721             try
1722             {
1723                 lStruct.setLecturerKeys(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherKey.fromProxyArraypProxy.LecturerKeys));
1724             }
1725             catch (DataTypeValidationException e)
1726             {
1727                 throw new DataTypeFieldValidationException("LecturerKeys", e);
1728             }
1729             return lStruct;
1730         }
1731     }
1732 
1733     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseResult enterprise data structure and
1734       * PXSTAddLecturersToCourseResult string based proxy structure.
1735       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1736     public static final class TRSTAddLecturersToCourseResult
1737     {
1738         private TRSTAddLecturersToCourseResult ()
1739         {
1740         }
1741 
1742         /** This method converts enterprise data structure to the string based proxy structure. */
1743         public static PXSTAddLecturersToCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddLecturersToCourseResult pStruct)
1744         {
1745             PXSTAddLecturersToCourseResult lProxy = new PXSTAddLecturersToCourseResult();
1746             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
1747             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1748             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1749             return lProxy;
1750         }
1751     }
1752 
1753     /** Adds one or more Lecturers to the specified Course instance.
1754       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1755       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1756       @exception BSException re-thrown from enteprise service component */
1757     public ADBSDataManagement.PXSTAddLecturersToCourseResult addLecturersToCourseADBSDataManagement.PXSTAddLecturersToCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
1758     {
1759         Context lContext = new InitialContext();
1760         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1761         return TRSTAddLecturersToCourseResult.toProxy(lService.addLecturersToCourse(TRSTAddLecturersToCourseInput.fromProxy(pInput)));
1762     }
1763 
1764     /** This class contains an input to the removeLecturersFromCourse operation */
1765     public static final class PXSTRemoveLecturersFromCourseInput
1766     {
1767     /** <p>The unique key identifying the Course to be edited.</p>
1768       */
1769         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey CourseKey;
1770     /** <p>The array of unique keys identifying Lecturers to be removed.</p>
1771       */
1772         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherKey[] LecturerKeys;
1773     }
1774 
1775     /** This class contains result of the removeLecturersFromCourse operation. */
1776     public static final class PXSTRemoveLecturersFromCourseResult
1777     {
1778         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
1779         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOTeacherInstanceNotFoundError TeacherNotFoundErrorMessage;
1780         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1781     }
1782 
1783     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseInput enterprise data structure and
1784       * PXSTRemoveLecturersFromCourseInput string based proxy structure.
1785       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1786     public static final class TRSTRemoveLecturersFromCourseInput
1787     {
1788         private TRSTRemoveLecturersFromCourseInput ()
1789         {
1790         }
1791 
1792         /** This method converts string based operation input structure to the enterprise operation input structure. */
1793         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseInput fromProxyPXSTRemoveLecturersFromCourseInput pProxythrows DataTypeFieldValidationException
1794         {
1795             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseInput();
1796             try
1797             {
1798                 lStruct.setCourseKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxypProxy.CourseKey));
1799             }
1800             catch (DataTypeValidationException e)
1801             {
1802                 throw new DataTypeFieldValidationException("CourseKey", e);
1803             }
1804             try
1805             {
1806                 lStruct.setLecturerKeys(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherKey.fromProxyArraypProxy.LecturerKeys));
1807             }
1808             catch (DataTypeValidationException e)
1809             {
1810                 throw new DataTypeFieldValidationException("LecturerKeys", e);
1811             }
1812             return lStruct;
1813         }
1814     }
1815 
1816     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseResult enterprise data structure and
1817       * PXSTRemoveLecturersFromCourseResult string based proxy structure.
1818       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1819     public static final class TRSTRemoveLecturersFromCourseResult
1820     {
1821         private TRSTRemoveLecturersFromCourseResult ()
1822         {
1823         }
1824 
1825         /** This method converts enterprise data structure to the string based proxy structure. */
1826         public static PXSTRemoveLecturersFromCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveLecturersFromCourseResult pStruct)
1827         {
1828             PXSTRemoveLecturersFromCourseResult lProxy = new PXSTRemoveLecturersFromCourseResult();
1829             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
1830             lProxy.TeacherNotFoundErrorMessage = TRMOTeacherInstanceNotFoundError.toProxy(pStruct.getTeacherNotFoundError());
1831             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1832             return lProxy;
1833         }
1834     }
1835 
1836     /** Removes one or more Lecturers from the specified Course instance.
1837       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1838       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1839       @exception BSException re-thrown from enteprise service component */
1840     public ADBSDataManagement.PXSTRemoveLecturersFromCourseResult removeLecturersFromCourseADBSDataManagement.PXSTRemoveLecturersFromCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
1841     {
1842         Context lContext = new InitialContext();
1843         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1844         return TRSTRemoveLecturersFromCourseResult.toProxy(lService.removeLecturersFromCourse(TRSTRemoveLecturersFromCourseInput.fromProxy(pInput)));
1845     }
1846 
1847     /** This class contains an input to the getAllLecturersForCourse operation */
1848     public static final class PXSTGetAllLecturersForCourseInput
1849     {
1850     /** <p>The unique key identifying the Course to be queried.</p>
1851       */
1852         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey CourseKey;
1853     }
1854 
1855     /** This class contains result of the getAllLecturersForCourse operation. */
1856     public static final class PXSTGetAllLecturersForCourseResult
1857     {
1858         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
1859         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1860     /** <p>Details of all Lecturers associated with the given Course</p>
1861       */
1862         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTTeacherDetails[] Lecturers;
1863     }
1864 
1865     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseInput enterprise data structure and
1866       * PXSTGetAllLecturersForCourseInput string based proxy structure.
1867       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1868     public static final class TRSTGetAllLecturersForCourseInput
1869     {
1870         private TRSTGetAllLecturersForCourseInput ()
1871         {
1872         }
1873 
1874         /** This method converts string based operation input structure to the enterprise operation input structure. */
1875         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseInput fromProxyPXSTGetAllLecturersForCourseInput pProxythrows DataTypeFieldValidationException
1876         {
1877             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseInput();
1878             try
1879             {
1880                 lStruct.setCourseKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxypProxy.CourseKey));
1881             }
1882             catch (DataTypeValidationException e)
1883             {
1884                 throw new DataTypeFieldValidationException("CourseKey", e);
1885             }
1886             return lStruct;
1887         }
1888     }
1889 
1890     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseResult enterprise data structure and
1891       * PXSTGetAllLecturersForCourseResult string based proxy structure.
1892       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1893     public static final class TRSTGetAllLecturersForCourseResult
1894     {
1895         private TRSTGetAllLecturersForCourseResult ()
1896         {
1897         }
1898 
1899         /** This method converts enterprise data structure to the string based proxy structure. */
1900         public static PXSTGetAllLecturersForCourseResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllLecturersForCourseResult pStruct)
1901         {
1902             PXSTGetAllLecturersForCourseResult lProxy = new PXSTGetAllLecturersForCourseResult();
1903             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
1904             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1905             lProxy.Lecturers = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTTeacherDetails.toProxyArraypStruct.getLecturers());
1906             return lProxy;
1907         }
1908     }
1909 
1910     /** Returns all Lecturers associated with the specified Course instance.
1911       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1912       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1913       @exception BSException re-thrown from enteprise service component */
1914     public ADBSDataManagement.PXSTGetAllLecturersForCourseResult getAllLecturersForCourseADBSDataManagement.PXSTGetAllLecturersForCourseInput pInputthrows BSException, DataTypeValidationException, NamingException
1915     {
1916         Context lContext = new InitialContext();
1917         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
1918         return TRSTGetAllLecturersForCourseResult.toProxy(lService.getAllLecturersForCourse(TRSTGetAllLecturersForCourseInput.fromProxy(pInput)));
1919     }
1920 
1921     /** This class contains an input to the addCoursesToStudent operation */
1922     public static final class PXSTAddCoursesToStudentInput
1923     {
1924     /** <p>The unique key identifying the Student to be edited.</p>
1925       */
1926         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentKey StudentKey;
1927     /** <p>The array of unique keys identifying Courses to be added.</p>
1928       */
1929         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey[] CourseKeys;
1930     }
1931 
1932     /** This class contains result of the addCoursesToStudent operation. */
1933     public static final class PXSTAddCoursesToStudentResult
1934     {
1935         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
1936         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
1937         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
1938     }
1939 
1940     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentInput enterprise data structure and
1941       * PXSTAddCoursesToStudentInput string based proxy structure.
1942       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1943     public static final class TRSTAddCoursesToStudentInput
1944     {
1945         private TRSTAddCoursesToStudentInput ()
1946         {
1947         }
1948 
1949         /** This method converts string based operation input structure to the enterprise operation input structure. */
1950         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentInput fromProxyPXSTAddCoursesToStudentInput pProxythrows DataTypeFieldValidationException
1951         {
1952             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentInput();
1953             try
1954             {
1955                 lStruct.setStudentKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentKey.fromProxypProxy.StudentKey));
1956             }
1957             catch (DataTypeValidationException e)
1958             {
1959                 throw new DataTypeFieldValidationException("StudentKey", e);
1960             }
1961             try
1962             {
1963                 lStruct.setCourseKeys(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxyArraypProxy.CourseKeys));
1964             }
1965             catch (DataTypeValidationException e)
1966             {
1967                 throw new DataTypeFieldValidationException("CourseKeys", e);
1968             }
1969             return lStruct;
1970         }
1971     }
1972 
1973     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentResult enterprise data structure and
1974       * PXSTAddCoursesToStudentResult string based proxy structure.
1975       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
1976     public static final class TRSTAddCoursesToStudentResult
1977     {
1978         private TRSTAddCoursesToStudentResult ()
1979         {
1980         }
1981 
1982         /** This method converts enterprise data structure to the string based proxy structure. */
1983         public static PXSTAddCoursesToStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STAddCoursesToStudentResult pStruct)
1984         {
1985             PXSTAddCoursesToStudentResult lProxy = new PXSTAddCoursesToStudentResult();
1986             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
1987             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
1988             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
1989             return lProxy;
1990         }
1991     }
1992 
1993     /** Adds one or more Courses to the specified Student instance.
1994       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
1995       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
1996       @exception BSException re-thrown from enteprise service component */
1997     public ADBSDataManagement.PXSTAddCoursesToStudentResult addCoursesToStudentADBSDataManagement.PXSTAddCoursesToStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
1998     {
1999         Context lContext = new InitialContext();
2000         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
2001         return TRSTAddCoursesToStudentResult.toProxy(lService.addCoursesToStudent(TRSTAddCoursesToStudentInput.fromProxy(pInput)));
2002     }
2003 
2004     /** This class contains an input to the removeCoursesFromStudent operation */
2005     public static final class PXSTRemoveCoursesFromStudentInput
2006     {
2007     /** <p>The unique key identifying the Student to be edited.</p>
2008       */
2009         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentKey StudentKey;
2010     /** <p>The array of unique keys identifying Courses to be removed.</p>
2011       */
2012         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseKey[] CourseKeys;
2013     }
2014 
2015     /** This class contains result of the removeCoursesFromStudent operation. */
2016     public static final class PXSTRemoveCoursesFromStudentResult
2017     {
2018         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOCourseInstanceNotFoundError CourseNotFoundErrorMessage;
2019         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
2020         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
2021     }
2022 
2023     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentInput enterprise data structure and
2024       * PXSTRemoveCoursesFromStudentInput string based proxy structure.
2025       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
2026     public static final class TRSTRemoveCoursesFromStudentInput
2027     {
2028         private TRSTRemoveCoursesFromStudentInput ()
2029         {
2030         }
2031 
2032         /** This method converts string based operation input structure to the enterprise operation input structure. */
2033         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentInput fromProxyPXSTRemoveCoursesFromStudentInput pProxythrows DataTypeFieldValidationException
2034         {
2035             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentInput();
2036             try
2037             {
2038                 lStruct.setStudentKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentKey.fromProxypProxy.StudentKey));
2039             }
2040             catch (DataTypeValidationException e)
2041             {
2042                 throw new DataTypeFieldValidationException("StudentKey", e);
2043             }
2044             try
2045             {
2046                 lStruct.setCourseKeys(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseKey.fromProxyArraypProxy.CourseKeys));
2047             }
2048             catch (DataTypeValidationException e)
2049             {
2050                 throw new DataTypeFieldValidationException("CourseKeys", e);
2051             }
2052             return lStruct;
2053         }
2054     }
2055 
2056     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentResult enterprise data structure and
2057       * PXSTRemoveCoursesFromStudentResult string based proxy structure.
2058       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
2059     public static final class TRSTRemoveCoursesFromStudentResult
2060     {
2061         private TRSTRemoveCoursesFromStudentResult ()
2062         {
2063         }
2064 
2065         /** This method converts enterprise data structure to the string based proxy structure. */
2066         public static PXSTRemoveCoursesFromStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STRemoveCoursesFromStudentResult pStruct)
2067         {
2068             PXSTRemoveCoursesFromStudentResult lProxy = new PXSTRemoveCoursesFromStudentResult();
2069             lProxy.CourseNotFoundErrorMessage = TRMOCourseInstanceNotFoundError.toProxy(pStruct.getCourseNotFoundError());
2070             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
2071             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
2072             return lProxy;
2073         }
2074     }
2075 
2076     /** Removes one or more Courses from the specified Student instance.
2077       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
2078       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
2079       @exception BSException re-thrown from enteprise service component */
2080     public ADBSDataManagement.PXSTRemoveCoursesFromStudentResult removeCoursesFromStudentADBSDataManagement.PXSTRemoveCoursesFromStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
2081     {
2082         Context lContext = new InitialContext();
2083         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
2084         return TRSTRemoveCoursesFromStudentResult.toProxy(lService.removeCoursesFromStudent(TRSTRemoveCoursesFromStudentInput.fromProxy(pInput)));
2085     }
2086 
2087     /** This class contains an input to the getAllCoursesForStudent operation */
2088     public static final class PXSTGetAllCoursesForStudentInput
2089     {
2090     /** <p>The unique key identifying the Student to be queried.</p>
2091       */
2092         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTStudentKey StudentKey;
2093     }
2094 
2095     /** This class contains result of the getAllCoursesForStudent operation. */
2096     public static final class PXSTGetAllCoursesForStudentResult
2097     {
2098         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXMOStudentInstanceNotFoundError StudentNotFoundErrorMessage;
2099         public com.almamater.adapters.generic.stringstructures.types.core.PXMOInvalidOperationInputError InvalidOperationInputErrorMessage;
2100     /** <p>Details of all Courses associated with the given Student</p>
2101       */
2102         public com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.PXSTCourseDetails[] Courses;
2103     }
2104 
2105     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentInput enterprise data structure and
2106       * PXSTGetAllCoursesForStudentInput string based proxy structure.
2107       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
2108     public static final class TRSTGetAllCoursesForStudentInput
2109     {
2110         private TRSTGetAllCoursesForStudentInput ()
2111         {
2112         }
2113 
2114         /** This method converts string based operation input structure to the enterprise operation input structure. */
2115         public static com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentInput fromProxyPXSTGetAllCoursesForStudentInput pProxythrows DataTypeFieldValidationException
2116         {
2117             com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentInput lStruct = new com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentInput();
2118             try
2119             {
2120                 lStruct.setStudentKey(com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTStudentKey.fromProxypProxy.StudentKey));
2121             }
2122             catch (DataTypeValidationException e)
2123             {
2124                 throw new DataTypeFieldValidationException("StudentKey", e);
2125             }
2126             return lStruct;
2127         }
2128     }
2129 
2130     /** This class contains utilities to translate data between com.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentResult enterprise data structure and
2131       * PXSTGetAllCoursesForStudentResult string based proxy structure.
2132       * This class is used internally in the adapter, but it can also be used externally by any code needing translation. */
2133     public static final class TRSTGetAllCoursesForStudentResult
2134     {
2135         private TRSTGetAllCoursesForStudentResult ()
2136         {
2137         }
2138 
2139         /** This method converts enterprise data structure to the string based proxy structure. */
2140         public static PXSTGetAllCoursesForStudentResult toProxycom.almamater.crs.services.coursesdomainsupport.BSDataManagement.STGetAllCoursesForStudentResult pStruct)
2141         {
2142             PXSTGetAllCoursesForStudentResult lProxy = new PXSTGetAllCoursesForStudentResult();
2143             lProxy.StudentNotFoundErrorMessage = TRMOStudentInstanceNotFoundError.toProxy(pStruct.getStudentNotFoundError());
2144             lProxy.InvalidOperationInputErrorMessage = com.almamater.adapters.generic.stringstructures.types.core.TRMOInvalidOperationInputError.toProxy(pStruct.getInvalidOperationInputError());
2145             lProxy.Courses = com.almamater.crs.adapters.generic.stringstructures.services.coursesdomainsupport.TRSTCourseDetails.toProxyArraypStruct.getCourses());
2146             return lProxy;
2147         }
2148     }
2149 
2150     /** Returns all Courses associated with the specified Student instance.
2151       @exception DataTypeValidationException thrown if any of the input strings did not pass validation during conversion to enterprise datatypes
2152       @exception NamingException thrown if this adapter was unable to lookup enteprise service component
2153       @exception BSException re-thrown from enteprise service component */
2154     public ADBSDataManagement.PXSTGetAllCoursesForStudentResult getAllCoursesForStudentADBSDataManagement.PXSTGetAllCoursesForStudentInput pInputthrows BSException, DataTypeValidationException, NamingException
2155     {
2156         Context lContext = new InitialContext();
2157         com.almamater.crs.services.coursesdomainsupport.BSDataManagement lService = (com.almamater.crs.services.coursesdomainsupport.BSDataManagement)lContext.lookup(com.almamater.crs.services.coursesdomainsupport.BSDataManagement.COMPONENT_URL);
2158         return TRSTGetAllCoursesForStudentResult.toProxy(lService.getAllCoursesForStudent(TRSTGetAllCoursesForStudentInput.fromProxy(pInput)));
2159     }
2160 }