Examples of IOTicket

com.mobixess.jodb.core.io.IOTicket

Examples of com.mobixess.jodb.core.io.IOTicket

            WrGlobalQueuedResorceCleaner.getInstance().register(owner, this);
        }
        public void cleanOnEnqueue() {
            for (int i = size()-1; i >= 0; --i) {
                try {
                    IOTicket ticket = elementAt(i);
                    ticket.close();
                } catch (IOException e) {
                    e.printStackTrace();//TODO add log?
                }
            }
        }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

        _activeObjectReferenceCleaner.removeStaleReferences();
        return _activeObjects.size();
    }
    
    public JODBQueryList getAllObjects() throws IOException{
        IOTicket ioTicket = _base.getIOTicket(true, false);
        ioTicket.lock(false);
        long[] offsets;
        try {
            offsets = _base.getForAllObjects(ioTicket);
        } finally {
            ioTicket.unlock();
        }
        ioTicket.close();
        return new SimpleArrayQueryList(offsets,this);
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

    public void activate(Object obj, int depth) throws IOException {
        PersistentObjectHandle handle = getHandleForActiveObject(obj);
        if(handle == null){
            return;
        }
        IOTicket ioTicket = _base.getIOTicket(true, false);
        ioTicket.lock(false);
        try {
            TransactionUtils.launchObject(this, handle.getObjectEntryOffset(), obj, depth);
        }catch (Exception e) {
            ioTicket.unlock();
        }
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

    }
    


    public JODBQueryList runQuery(LongVector excludedObjects, LongVector dynamicLongArray) throws IOException, IllegalClassTypeException{
        IOBase base = _session.getBase();
        IOTicket ticket = base.getIOTicket(true, false);
        SortDataCache sortDataCache = new SortDataCache();
        initSortDataCache(sortDataCache, new StringBuffer());
        if(sortDataCache.getSortNodesCacheSize()>0){
            sortDataCache.setValuesAccumulationMode();
        }else{
            sortDataCache.clearAll();
            sortDataCache = null;
        }
        JODBOperationContext context = new JODBOperationContext(_session,ticket,sortDataCache,null,null,excludedObjects,true);
        IndexDataIterator indexIterator = null;
        boolean skipConventionalSorting = false;


        FieldRecord indexDataIteratorFieldRecord = null;//used for iteraion through indexed data
        QueryNode indexedNode = null;
        TypeConstraint typeConstraint = null;
        try{
            
            Vector<ConstraintBase> vectorOfConstraints = _constraints._constraints;
            for (int i = 0; i < vectorOfConstraints.size(); i++) {
                ConstraintBase nextCandidate = vectorOfConstraints.elementAt(i);
                if(nextCandidate instanceof TypeConstraint){
                    if(typeConstraint == null){
                        typeConstraint = (TypeConstraint) nextCandidate;
                    }else{
                        typeConstraint = null;//multiple type constraints
                        break;
                    }
                }
            }
            
            if(typeConstraint != null){
                //boolean useIndexDataFromIterator = false;
                JODBIndexingRootAgent indexingRootAgent = _session.getIndexingRootAgent();
                ClassDescriptor classDescriptor = _session.getDescriptorForClass((Class)typeConstraint.getObject());
                JODBIndexingAgent indexingAgent = null;
                if(sortDataCache!=null){
                    //lookup indexing data to optimize query
                    SortNodeRecord[] sortRecords = sortDataCache.getSortNodes();
                    int fieldId = classDescriptor.getFieldIDForName(sortRecords[0]._fullPath);
                    if(fieldId!=-1){
                        indexingAgent = indexingRootAgent.getIndexingAgent(fieldId, base);
                        if(indexingAgent!=null){
                            indexIterator = indexingAgent.getIndexIterator(sortRecords[0]._orderAscending);
                            indexedNode = _descendants.get(sortRecords[0]._fullPath);
                            skipConventionalSorting = sortRecords.length == 1;
                        }
                    }
                }
                if(indexIterator == null){
                    //search first index
                    Iterator<String> descendants = _descendants.keySet().iterator();
                    while (descendants.hasNext() && indexIterator == null) {
                        String next = descendants.next();
                        Field field = classDescriptor.getFieldForName(next);
                        if(field==null){
                            continue;
                        }
                        indexingAgent = indexingRootAgent.getIndexingAgent(field, base);
                        if(indexingAgent!=null){
                            indexIterator = indexingAgent.getIndexIterator(true);
                            indexedNode = _descendants.get(next);
                        }
                    }
                }
                if(indexingAgent!=null && indexedNode != null){
                    Field field = classDescriptor.getFieldForID(indexingAgent.getFieldId(), null);
                    Class fieldType = field.getType();                        
                    if(fieldType.isPrimitive()){
                        indexDataIteratorFieldRecord = new FieldRecord();
                        indexDataIteratorFieldRecord._fieldID = indexingAgent.getFieldId();
                        indexDataIteratorFieldRecord._category = FIELD_CATEGORIES.PRIMITIVE;
                        indexDataIteratorFieldRecord._fieldTypeID = base.getClassTypeSubstitutionID(fieldType.getName());
                    }
                }
            }
            if(indexIterator==null){
                indexIterator = new LArrayIndexIterator(base.getForAllObjects(ticket));
            }


            LArrayChunkedBuffer acceptedIds = new LArrayChunkedBuffer();


            while (indexIterator.hasNext()) {
                resetStateOfConstraints();
                CONSTRAINT_EVALUATION_STATUS status = CONSTRAINT_EVALUATION_STATUS.UNKNOWN;
                long nextObjectId;
                if(indexDataIteratorFieldRecord!=null){
                    indexDataIteratorFieldRecord._primitiveRawDataBuffer.clear();
                    nextObjectId = indexIterator.next(indexDataIteratorFieldRecord._primitiveRawDataBuffer);
                    if(excludedObjects!=null && excludedObjects.binarySearch(nextObjectId)>=0){
                        continue;
                    }
                    if(_session.getObjectFromCache(nextObjectId) == null){
                        //do not analize active objects
                        indexDataIteratorFieldRecord._primitiveRawDataBuffer.flip();
                        if(sortDataCache!=null){
                            sortDataCache.setCandidateID(nextObjectId);
                        }
                        indexedNode.analize(-1, indexDataIteratorFieldRecord, context);
                        typeConstraint.setStatus(CONSTRAINT_EVALUATION_STATUS.ACCEPTED);
                        _constraints.markExistanceConstrantAsAccepted();
                        indexedNode._constraints.markExistanceConstrantAsAccepted();
                        status = getCumulativeStatus();
                    }
                }else{
                    nextObjectId = indexIterator.next();
                    if(excludedObjects!=null && excludedObjects.binarySearch(nextObjectId)>=0){
                        continue;
                    }
                }
                if(status == CONSTRAINT_EVALUATION_STATUS.UNKNOWN){
                    if(sortDataCache!=null){
                        sortDataCache.setCandidateID(nextObjectId);
                    }
                    status = analize(nextObjectId,context);
                }
                if(status == CONSTRAINT_EVALUATION_STATUS.EXCLUDED){
                    if( !context.isExcludedObjectId(nextObjectId) ){
                        dynamicLongArray.addElement(nextObjectId);
                    }
                    continue;
                }
                if(status == CONSTRAINT_EVALUATION_STATUS.ACCEPTED){
                    if(sortDataCache!=null && JODBConfig.useCacheOnSortOperations()){
                        sortDataCache.acceptCandidate();
                    }
                    acceptedIds.add(nextObjectId);
                }
            }


            long[] resultingOffsets = acceptedIds.toArray();


            if(!skipConventionalSorting){
                handleSortInstructions(sortDataCache, context, resultingOffsets);
            }
            return new SimpleArrayQueryList(resultingOffsets, _session);
        }finally {
            if(sortDataCache!=null){
                sortDataCache.clearAll();
            }
            ticket.close();
        }
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

            return getCumulativeStatus();
        }
        DataContainersCache dataContainersCache = TransactionUtils.getObjectDataContainerCache();
        ObjectDataContainer dataContainer = dataContainersCache.pullObjectDataContainer();
        IOBase base = _session.getBase();
        IOTicket ticket = base.getIOTicket(true, true);
        try {//TODO need handling for arrays
            dataContainer.readObject(ticket.getRandomAccessBuffer(), base, context.getSession(), objectOffset, true);
            return analize(classDescriptor, dataContainer, context);
        } finally {
            TransactionUtils.getObjectDataContainerCache().pushObjectDataContainer(dataContainer);
            ticket.close();
        }
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

        }
        
        IOBase base = context.getBase();
        DataContainersCache dataContainersCache = TransactionUtils.getObjectDataContainerCache();
        ObjectDataContainer dataContainer = dataContainersCache.pullObjectDataContainer();
        IOTicket ticket = context.getIoTicket();
        try {
            dataContainer.readObject(ticket.getRandomAccessBuffer(), base, context.getSession(), objectID, true);
            readSortData( dataContainer, (FieldRecord)null, sortDataCache, context);
        } finally {
            TransactionUtils.getObjectDataContainerCache().pushObjectDataContainer(dataContainer);
        }        
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

            }
        }else{
            instance = activationInstance;
        }
        OperationContextTicketCache contextTicketCache = _threadLocalTicketCacheHolder.get(); 
        IOTicket ioTicket = contextTicketCache.getTicketForRead(base);//base.getIOTicket(true, false);
        try{
            ioTicket.lock(false);
            DataContainersCache dataContainersCache = getObjectDataContainerCache();
            ObjectDataContainer objectDataContainer = dataContainersCache.pullObjectDataContainer();
            FieldsIterator fieldsIterator = objectDataContainer.readObject(ioTicket.getRandomAccessBuffer(),base, session, offset, true);
            ClassDescriptor classDescriptor = objectDataContainer.getClassDescriptorForPersistedObject();
            if (classDescriptor == null || fieldsIterator == null) {
                // basically same as >>objectDataContainer.isDeleted()<< or no class available for persistent copy
                return null;
            }
            IClassProcessor processor;
            if (!delayedActivation) {
                int classTypeId = objectDataContainer.getOriginalClassType();
                String className = base.getClassTypeForID(classTypeId);
                Class clazz;
                try {
                    clazz = session.resolveClassForName(className);
                } catch (ClassNotFoundException e) {
                    return null;
                }
                processor = JODBPluginRegistry.getInstance().getClassProcessor(clazz);
                instance = processor.composeInstance(clazz, objectDataContainer, session);
            }else{
                processor = JODBPluginRegistry.getInstance().getClassProcessor(instance.getClass());
            }
            PersistentObjectHandle handle = session.createHandleForObject(instance, offset, objectDataContainer);
            synchronized (handle) {//TODO "get object" must obey this lock or incompletely initialized object could become accessible
                if(!delayedActivation){
                    synchronized (session.getActivationSynchObject()) {//put object into cache to prevent potential recursion
                        //check if some other thread already instantiated the object
                        Object candidate = session.getObjectFromCache(offset);
                        if (candidate != null) {
                            dataContainersCache.pushObjectDataContainer(objectDataContainer);//return container to cache
                            return candidate;
                        }
                        session.putObject(instance, handle);
                    }
                }
    
                processor.activate(instance, objectDataContainer, session, remainingDepth, delayedActivation);
                dataContainersCache.pushObjectDataContainer(objectDataContainer);//return container to cache
                objectDataContainer = null;
            }
        }finally{
            ioTicket.unlock();
            contextTicketCache.putToCache(ioTicket);
        }
        return instance;
    }

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

        }
        
        IOTicket getTicketForRead(IOBase base) throws IOException{
            if(_ioTicketsCache!=null && _ioTicketsCache.size() > 0){
                int index = _ioTicketsCache.size()-1;
                IOTicket result = _ioTicketsCache.elementAt(index);
                if(result.getBase() != base){
                    if(JODBConfig.DEBUG){
                        throw new IOException("Illegal Cache Content");
                    }
                    _ioTicketsCache = null;// clean cache
                }else{

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

            throw new IOException("transaction handle unavailable");
        }
        if(!tContainer.isAgentsMode() && tHandle.isAgent()){
            return 0;
        }
        IOTicket ioTicket = context.getIoTicket();
        JODBSession session = context.getSession();
        if(tHandle.isTranslated()){
            return tHandle.getTransactionOffset();
        }
        tContainer.fireOnCommitStarted(rootObject, context.getSession());
        if(tHandle.is_DELETE_Transaction()){
            deleteObject(ioTicket, session, tHandle, tContainer);
            return -1;
        }
        IOBase base = ioTicket.getBase();
        
        
        IClassProcessor classProcessor = JODBPluginRegistry.getInstance().getClassProcessor(rootObject.getClass());
        
        Object objectToPersist = classProcessor.translate(rootObject); 
        
        ClassDescriptor classDescr = session.getDescriptorForClass(objectToPersist.getClass());
        FieldAndIDRecord[] fields = classDescr.getAllFields();
        
        Vector<IndexingRecord> indexes = null;
        
        Class rootObjectType = rootObject.getClass();
        int rootObjectClassID;
        if(rootObjectType.isArray()){
            rootObjectClassID = base.getOrSetClassTypeSubstitutionID(rootObjectType.getComponentType().getName());
        }else{
            rootObjectClassID = base.getOrSetClassTypeSubstitutionID(rootObjectType.getName());
            indexes = TransactionUtils.getObjectDataContainerCache().pullVector();
            JODBIndexingRootAgent indexingAgent = context.getIndexingRootAgent();
            indexingAgent.getAgentsForClassId(indexes, rootObjectClassID);
            if(indexes.size() == 0){
                //no indexes for this class
                TransactionUtils.getObjectDataContainerCache().pushVector(indexes);
                indexes = null;
            }
        }
        tHandle.setIndexes(indexes);
        //String[] classTypes = classDescr.getTypes();
        
        if( checkActiveObjectUnchanged(classProcessor, context, objectToPersist, tHandle, persistentCopyObjectDataContainer, indexes) ){//should not happen in recursive sub call
            tHandle.setIndexes(null);//reset indexes info in handle to prevent post processing
            long offset = tHandle.getHandle().getObjectEntryOffset();//JODBIOUtils.addAbsoluteOffsetIdentifierBit(tHandle.getHandle().getObjectEntryOffset());
            tHandle.setTransactionOffset(offset);
            if( classDescr.isArray()){
                if(classDescr.isPrimitiveArray()){
                    return offset;
                }
                int arrayLen = Array.getLength(objectToPersist);
                for (int i = 0; i < arrayLen; i++) {
                    Object childObj = Array.get(objectToPersist, i);
                    if(childObj == null || transactionObjects.get(childObj) == null){
                        continue;
                    }
                    assembleTransactionDataForObject(context, childObj, tContainer);
                }
            } else {
                try {
                    for (int i = 0; i < fields.length; i++) {
                        Field field = fields[i]._field;
                        if (field.getType().isPrimitive()) {
                            continue;
                        }
                        Object childObj = field.get(objectToPersist);
                        if (childObj == null || transactionObjects.get(childObj) == null){
                            continue;
                        }
                        assembleTransactionDataForObject(context, childObj, tContainer);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new JodbIOException(e);
                }
            }            
            return offset;
        }
        
        IRandomAccessDataBuffer transactionFile = tContainer.getTransactionNewDataFile();
        transactionFile.resetToEnd();
        
        Vector<ObjectFieldRecord> fieldsWithAbsoluteAddr = new Vector<ObjectFieldRecord>();
        Vector<ObjectFieldRecord> fieldsWithRelativeAddr = new Vector<ObjectFieldRecord>();
        Vector<Field> primitiveFields = new Vector<Field>();
        
        if(!classDescr.isArray()){
            classifyFields(objectToPersist, classDescr, transactionObjects, fieldsWithAbsoluteAddr, fieldsWithRelativeAddr, primitiveFields);
        }
        
        
        long objectIDOffset = transactionFile.getCursorOffset();
        
        tHandle.setTransactionOffset(objectIDOffset);


        if(JODBConfig.DEBUG){
            _logger.info(" >>> Transaction: Object "+rootObject.getClass()+" "+rootObject+" start offset ="+objectIDOffset);
        }
        
        boolean translated = rootObject!=objectToPersist;
        byte arrayElementSize = 0;
        long lengthEstimate;
        if(!classDescr.isArray()){
            lengthEstimate = estimateObjectLength(tHandle, fieldsWithAbsoluteAddr.size(), fieldsWithRelativeAddr.size(), classDescr, translated);
        }else{
            ByteHolder byteHolder = new ByteHolder();
            lengthEstimate = estimateArrayObjectLength(context, tHandle, objectToPersist, classDescr, byteHolder, translated);
            arrayElementSize = byteHolder._value;
        }
        
        int objId = composeEntryID( JODBIOBase.ENTRY_OBJECT_ID, lengthEstimate);
        int objIdWithRedirectionBit = tHandle.isNewObject()? objId : JODBIOBase.addRedirectedObjectModifier(objId);
        transactionFile.writeShort(objIdWithRedirectionBit);
        writeEntryLenForID(objId,0,transactionFile);//reserve space for length
        
        long objectBodyOffset = transactionFile.getCursorOffset();
        
//        if(JODBConfig.DEBUG){
//            _logger.info("Transaction: Object "+rootObject.getClass()+" "+rootObject+" header len ="+headerLen);
//        }
        
        int primaryMask = formPrimaryObjectMask(0, fieldsWithAbsoluteAddr.size()>0, fieldsWithRelativeAddr.size()>0, primitiveFields.size()>0, translated, tHandle, classDescr);;
        
        transactionFile.writeByte(primaryMask);
        
        int secondaryMask = formSecondaryObjectMask(0, tHandle);
        
        transactionFile.writeByte(secondaryMask);
        
        short newCyclicCounter =  (short) (tHandle.getCyclicalVersionCounter()+1);
        
        if(newCyclicCounter == 256){
            newCyclicCounter = 0;
        }
        tHandle.setCyclicalVersionCounter(newCyclicCounter);
        
        transactionFile.writeByte(newCyclicCounter);
        
        tHandle.setTranslatedObjectDataMask((byte) primaryMask);
        
        //
        if(tHandle.generateUID()){
            Random random = new Random();
            transactionFile.writeLong(random.nextLong());
        }
        long time = System.currentTimeMillis();
        if(tHandle.generateCreationTS()){
            transactionFile.writeLong(time);
        }
        if(tHandle.generateModificationTS()){
            transactionFile.writeLong(time);
        }
        
        //
        transactionFile.writeShort(rootObjectClassID);
        
        if(translated){
            int translatedObjectClassID = base.getOrSetClassTypeSubstitutionID(classDescr.getTypes()[0]);// base.getOrSetClassTypeSubstitutionID( objectToPersist.getClass().getName());
            transactionFile.writeShort(translatedObjectClassID);
        }
        
//        transactionFile.writeShort(classTypes.length);
//        
//        for (int i = 0; i < classTypes.length; i++) {
//            int id = base.getOrSetClassTypeSubstitutionID(classTypes[i]);
//            transactionFile.writeShort(id);
//        }


        if(fieldsWithAbsoluteAddr.size()>0){//with absolute offsets
            transactionFile.writeShort(fieldsWithAbsoluteAddr.size());
            for (int i = 0; i < fieldsWithAbsoluteAddr.size(); i++) {//writing links of unchanged objects
                ObjectFieldRecord next = fieldsWithAbsoluteAddr.elementAt(i);
                int id = base.getOrSetFieldSubstitutionID(next._field);
                transactionFile.writeShort(id);
                TransactionHandle valueHandle = transactionObjects.get(next._value);
                transactionFile.writeLong(valueHandle.getHandle().getObjectEntryOffset());
            }
        }
        
        long objectsWithRelativeAddrStartOffsetShift = -1;
        if(fieldsWithRelativeAddr.size()>0){//with relative offsets
            transactionFile.writeShort(fieldsWithRelativeAddr.size());
            objectsWithRelativeAddrStartOffsetShift = transactionFile.getCursorOffset() - objectIDOffset;
            transactionFile.setLength(transactionFile.length()+ fieldsWithRelativeAddr.size()*(2+4));
            transactionFile.seek(transactionFile.length());
        }
        
        if(primitiveFields.size()>0){
            transactionFile.writeShort(primitiveFields.size());
        }
        for (int i = 0; i < primitiveFields.size(); i++) {
            Field next = primitiveFields.elementAt(i);
            int id = base.getOrSetFieldSubstitutionID(next);
            transactionFile.writeShort(id);
            IndexingRecord record = IndexingRecord.findIndexingRecord(id, indexes);
            if(record!=null){
                //ByteBuffer currentlyPersistedValue = record.getPersistedDataBuffer();
                ByteBuffer pendingValue = record.getPendingDataBuffer();
                pendingValue.clear();
                PrimitiveJavaTypesUtil.primitiveToByteBuffer(objectToPersist, next, pendingValue);
                pendingValue.flip();
                transactionFile.getChannel().write(pendingValue);
                pendingValue.rewind();
            }else {
                try {
                    Utils.writePrimitive(objectToPersist, next,transactionFile);
                } catch (Exception e) {
                    throw new JodbIOException(e);
                }
            }            
        }
        
        long arrayDataShift = 0;
        if(classDescr.isArray()){
            int arrayLength = Array.getLength(objectToPersist);
            transactionFile.writeInt(arrayLength);
            transactionFile.writeByte(arrayElementSize);//write length of each element in array
            arrayDataShift = transactionFile.getCursorOffset() - objectIDOffset;
            boolean primitive = classDescr.isPrimitiveArray();
            if(primitive){//completely write primitive array
                try {
                    Utils.writePrimitiveArray(objectToPersist, classDescr.getArrayType(), 0, arrayLength, transactionFile);
                } catch (Exception e) {
                    _logger.log(Level.SEVERE,"",e);
                    throw new JodbIOException(e);
                }
            }else{//reserve space for references
                long spaceToReserve = arrayElementSize*arrayLength;
                long slotMasksTotal = arrayLength/8;
                if( slotMasksTotal*8 != arrayLength){
                    slotMasksTotal++;//trailing mask entry for slot <8
                }
                spaceToReserve+=slotMasksTotal;
                if(transactionFile.getCursorOffset() + spaceToReserve > transactionFile.length()  ){
                    transactionFile.setLength(transactionFile.getCursorOffset() + spaceToReserve );
                }
                transactionFile.skip(spaceToReserve);
                
            }
        }
        
        if(JODBConfig.DEBUG){
            _logger.info(" <<< Transaction: Object "+rootObject.getClass()+" "+rootObject+" end offset ="+transactionFile.getCursorOffset());
        }
        
        long objectEndOffset = transactionFile.getCursorOffset();
        long objectBodyLength = objectEndOffset - objectBodyOffset;
        if(lengthEstimate < objectBodyLength){
            throw new JodbIOException("Object length estimate error");
        }
        //long targetObjectBodyLength = objectBodyLength;
        
        if(!tHandle.isNewObject()){
            DataContainersCache dataContainersCache = TransactionUtils.getObjectDataContainerCache();
            ObjectDataContainer existingObjectHeaderData =  dataContainersCache.pullObjectDataContainer();// tContainer.getTempObjectDataContainer();


            //ioTicket.getRandomAccessBuffer().seek(tHandle.getHandle().getObjectEntryOffset());
            //JODBIOUtils.readObjectHeader(ioTicket, existingObjectHeaderData, false);
            existingObjectHeaderData.readHeader(ioTicket.getRandomAccessBuffer(),tHandle.getHandle().getObjectEntryOffset(), false);
            tHandle.setTransactionOffset(existingObjectHeaderData.getOffset());//JODBIOUtils.addAbsoluteOffsetIdentifierBit(existingObjectHeaderData.getOffset()));//if object already existed than alvays point to initial object position
            long redirectorOffset = existingObjectHeaderData.isRedirection()?existingObjectHeaderData.getOffset():-1;
            if(objectBodyLength > existingObjectHeaderData.getBodyLength() || fieldsWithRelativeAddr.size() > 0 ){
                if( existingObjectHeaderData.isRedirection() ){
                    //redirection entry space is too small, let see what is under redirection offset
                    //ioTicket.getRandomAccessBuffer().seek(existingObjectHeaderData.getRedirectionOffset());
                    long existingObjectRedirectionOffset = existingObjectHeaderData.getRedirectionOffset();
                    existingObjectHeaderData.reset();
                    existingObjectHeaderData.readHeader(ioTicket.getRandomAccessBuffer(), existingObjectRedirectionOffset, true);
                    //JODBIOUtils.readObjectHeader(ioTicket, existingObjectHeaderData, true);
                }
            }


            if(objectBodyLength <= existingObjectHeaderData.getBodyLength() && fieldsWithRelativeAddr.size() == 0){

View Full Code Here

Examples of com.mobixess.jodb.core.io.IOTicket

        JODBIndexingAgent indexingAgent = indexingRootAgent.getIndexingAgent(field, _base);
        if((indexingAgent!=null && enable)|| (indexingAgent == null && !enable) ){
            return;
        }
        
        IOTicket writeTicket = _base.getIOTicket(true, true);
        try{
            JODBOperationContext context = new JODBOperationContext(_session, writeTicket, null, _transactionContainer, indexingRootAgent);
            writeTicket.lock(true);
            
            if(!enable){
                indexingRootAgent.removeAgent(field, context);
                return;
            }
            
            indexingAgent = indexingRootAgent.enableIndex(field, context );
            
            _base.applyTransaction(_transactionContainer, _session, writeTicket, indexingRootAgent, this);
            
        }finally {
            writeTicket.unlock();//should be already released in "applyTransaction()", just to play safe
        }
    }

View Full Code Here

0 1

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.