jco$record.java

SAP这个系统的一个转换器

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   JCO.java

package com.sap.mw.jco;

import com.sap.mw.jco.util.Codecs;
import com.sap.mw.jco.util.SyncDateFormat;
import com.sap.mw.jco.util.XMLReaderBase;
import com.sap.mw.jco.util.XMLWriterBase;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Date;

// Referenced classes of package com.sap.mw.jco:
//            IMetaData, JCO, IExtendedFieldMetaData

public static class JCO$Record extends a
    implements Cloneable, Serializable
{
    protected static class XMLWriter extends XMLWriterBase
    {

        public static String createXMLDocument(JCO.Record record, String root_tag)
        {
            return createXMLDocument(record, root_tag, null, null);
        }

        public static String createXMLDocument(JCO.Record record, String root_tag, String namespace, String namespace_urn)
        {
            String document = null;
            try
            {
                XMLWriter w = new XMLWriter();
                w.encode(record, root_tag, namespace, namespace_urn);
                document = w.toString();
                if(JCO.trace_level > 9)
                {
                    StringBuffer buffer = new StringBuffer(document);
                    for(int i = 0; i < buffer.length(); i += 80)
                        buffer.insert(i, "\n");

                    JCO.fireTrace(10, "[JAV-LAYER] JCO.Record.XMLWriter.createXMLDocument(" + record.getName() + ") " + buffer);
                }
            }
            catch(IOException ex)
            {
                throw new JCO.ConversionException(ex.getMessage());
            }
            return document;
        }

        public static void writeXMLDocument(JCO.Record record, String root_tag, Writer writer)
            throws IOException
        {
            XMLWriter w = new XMLWriter(writer);
            w.encode(record, root_tag, null, null).flush();
        }

        public static void writeXMLDocument(JCO.Record record, String root_tag, String namespace, String namespace_urn, Writer writer)
            throws IOException
        {
            XMLWriter w = new XMLWriter(writer);
            w.encode(record, root_tag, namespace, namespace_urn).flush();
        }

        public XMLWriter encode(JCO.Record record, String root_tag)
            throws IOException
        {
            return encode(record, root_tag, null, null);
        }

        public XMLWriter encode(JCO.Record record, String root_tag, String namespace, String namespace_urn)
            throws IOException
        {
            m_record = record;
            m_namespace_urn = namespace_urn;
            int num_fields = m_record.getNumFields();
            if(num_fields == 1 && m_record.getName().length() == 0)
            {
                m_tags = null;
            } else
            {
                m_tags = new String[num_fields];
                for(int i = 0; i < num_fields; i++)
                    m_tags[i] = escape(m_record.getName(i));

            }
            if(root_tag != null)
                root_tag = escape(root_tag);
            String root_stag = root_tag;
            String root_etag = root_tag;
            String row_tag = "ITEM";
            if(root_tag != null && namespace != null)
            {
                StringBuffer sb = new StringBuffer(root_stag.length() + namespace.length());
                sb.append(namespace);
                sb.append(':');
                sb.append(root_stag);
                root_etag = sb.toString();
                if(namespace_urn != null)
                {
                    sb.append(" xmlns:");
                    sb.append(namespace);
                    sb.append("=\"");
                    sb.append(namespace_urn);
                    sb.append('"');
                }
                root_stag = sb.toString();
            }
            if(m_namespace_urn != null && m_namespace_urn.equals("urn:sap-com:document:sap:soap:functions:uc-style"))
                row_tag = record.getLineTypeName() == null ? "ITEM" : record.getLineTypeName();
            else
                row_tag = "item";
            int row_save = m_record.row;
            try
            {
                if(root_stag != null)
                    stag(root_stag);
                for(m_record.row = 0; m_record.row < m_record.num_rows; m_record.row++)
                {
                    if((m_record.rec_type & 4) != 0)
                        stag(row_tag);
                    for(int i = 0; i < num_fields; i++)
                        element(i);

                    if((m_record.rec_type & 4) != 0)
                        etag(row_tag);
                }

                if(root_etag != null)
                    etag(root_etag);
            }
            finally
            {
                m_record.row = row_save;
            }
            return this;
        }

        public XMLWriter element(int index)
            throws IOException
        {
            int itype = ((JCO.MetaData) (m_record)).type[index];
            String tag = m_tags == null ? null : m_tags[index];
            stag(tag);
            switch(itype)
            {
            case 0: // '\0'
            case 6: // '\006'
                int ioffset = ((JCO.MetaData) (m_record)).boffset[index] + m_record.row * m_record.row_length;
                int ilength = ((JCO.MetaData) (m_record)).blength[index];
                content(m_record.data, ioffset, ilength);
                break;

            case 4: // '\004'
            case 30: // '\036'
                content(m_record.getByteArray(index));
                break;

            case 17: // '\021'
            case 99: // 'c'
                XMLWriter w = new XMLWriter(this, null);
                w.encode((JCO.Record)m_record.getValue(index), null, null, m_namespace_urn);
                w.close();
                break;

            case 1: // '\001'
            case 3: // '\003'
                if(super.m_escape_mode == 2 || super.m_escape_mode == 3)
                {
                    int ioffset = ((JCO.MetaData) (m_record)).boffset[index] + m_record.row * m_record.row_length;
                    int ilength = ((JCO.MetaData) (m_record)).blength[index];
                    content(m_record.data, ioffset, ilength);
                } else
                {
                    content(m_record.getString(index));
                }
                break;

            default:
                content(m_record.getString(index));
                break;
            }
            etag(tag);
            return this;
        }

        public static final String DEFAULT_NAMESPACE = "rfc";
        protected String m_namespace_urn;
        protected String m_tags[];
        protected JCO.Record m_record;

        public XMLWriter()
        {
            m_tags = null;
            m_record = null;
        }

        public XMLWriter(Writer writer)
        {
            this(null, writer);
        }

        public XMLWriter(XMLWriter parent, Writer writer)
        {
            super(parent, writer);
            m_tags = null;
            m_record = null;
        }
    }

    protected static class XMLReader extends XMLReaderBase
    {

        public static void readXMLDocument(JCO.Record record, String xmldoc)
        {
            XMLReader parser = new XMLReader(record);
            parser.parse(xmldoc);
        }

        public static void readXMLDocument(JCO.Record record, Reader reader)
        {
            XMLReader parser = new XMLReader(record);
            parser.parse(reader);
        }

        protected void store(JCO.Record record, char value[], int offset, int length, int index)
        {
            record.encodeGENERIC(value, offset, length, index);
        }

        public XMLReader(JCO.Record record)
        {
            super(record);
        }
    }

    protected class Type1Record
        implements Cloneable, Serializable
    {

        public Object clone()
        {
            try
            {
                Type1Record obj = (Type1Record)super.clone();
                obj.copy(this);
                return obj;
            }
            catch(CloneNotSupportedException ex)
            {
                return null;
            }
        }

        protected void copy(Type1Record type1Record)
        {
            if(type1Record == null)
            {
                return;
            } else
            {
                ensureCapacity(type1Record.row_length);
                row_length = type1Record.row_length;
                System.arraycopy(type1Record.data, 0, data, 0, row_length);
                return;
            }
        }

        private void ensureCapacity(int capacity)
        {
            if(data.length < capacity)
            {
                char old_data[] = data;
                data = new char[capacity];
                System.arraycopy(old_data, 0, data, 0, old_data.length);
            }
        }

        protected void ensureBufferCapacity()
        {
            if(row_length == 0 && type1_data.num_fields > 0)
                row_length = type1_data.boffset[type1_data.num_fields - 1] + type1_data.blength[type1_data.num_fields - 1];
            if(data.length < row_length)
            {
                char old_data[] = data;
                data = new char[row_length];
                System.arraycopy(old_data, 0, data, 0, old_data.length);
            }
        }

        protected void initialize()
        {
            initializeRow(0);
            nested2Flat();
        }

        protected void nested2Flat()
        {
            ensureBufferCapacity();
            nested2Flat(JCO.Record.this, 0);
        }

        private final int nested2Flat(JCO.Record record, int dataOffset)
        {
            int i = 0;
            int lastCopyIndex = 0;
            for(; i < ((JCO.MetaData) (record)).num_fields; i++)
                if(((JCO.MetaData) (record)).type[i] == 17)
                {
                    if(i > lastCopyIndex)
                    {
                        int startOffset = ((JCO.MetaData) (record)).boffset[lastCopyIndex];
                        int dataLength = (((JCO.MetaData) (record)).boffset[i - 1] + ((JCO.MetaData) (record)).blength[i - 1]) - startOffset;
                        System.arraycopy(record.data, startOffset, data, dataOffset, dataLength);
                        dataOffset += dataLength;
                    }
                    lastCopyIndex = i + 1;
                    dataOffset = nested2Flat(((JCO.Record) (record.decodeSTRUCTURE(i))), dataOffset);
                }

            if(i > lastCopyIndex)
            {
                int startOffset = ((JCO.MetaData) (record)).boffset[lastCopyIndex];
                int dataLength = (((JCO.MetaData) (record)).boffset[i - 1] + ((JCO.MetaData) (record)).blength[i - 1]) - startOffset;
                System.arraycopy(record.data, startOffset, data, dataOffset, dataLength);
                dataOffset += dataLength;
            }
            return dataOffset;
        }

        protected void flat2Nested()
        {
            flat2Nested(JCO.Record.this, 0);
        }

        private final int flat2Nested(JCO.Record record, int dataOffset)
        {
            int i = 0;
            int lastCopyIndex = 0;
            for(; i < ((JCO.MetaData) (record)).num_fields; i++)
                if(((JCO.MetaData) (record)).type[i] == 17)
                {
                    if(i > lastCopyIndex)
                    {
                        int startOffset = ((JCO.MetaData) (record)).boffset[lastCopyIndex];
                        int dataLength = (((JCO.MetaData) (record)).boffset[i - 1] + ((JCO.MetaData) (record)).blength[i - 1]) - startOffset;
                        System.arraycopy(data, dataOffset, record.data, startOffset, dataLength);
                        dataOffset += dataLength;
                    }
                    lastCopyIndex = i + 1;
                    dataOffset = flat2Nested(((JCO.Record) (record.decodeSTRUCTURE(i))), dataOffset);
                }

            if(i > lastCopyIndex)
            {
                int startOffset = ((JCO.MetaData) (record)).boffset[lastCopyIndex];
                int dataLength = (((JCO.MetaData) (record)).boffset[i - 1] + ((JCO.MetaData) (record)).blength[i - 1]) - startOffset;
                System.arraycopy(data, dataOffset, record.data, startOffset, dataLength);
                dataOffset += dataLength;
            }
            return dataOffset;
        }

        protected void cleanup()
        {
            row_length = 0;
            data = new char[0];
        }

        protected void internalSize(JCO.DataSize size)
        {
            size.addDataBytes(data.length * 2);
        }

        protected void finalize()
        {
            if(JCO.trace_level > 9)
                JCO.fireTrace(10, "[JAV-LAYER] Type1Record.finalize() [<<< " + ((Object)this).hashCode() + "]");
        }

        protected char data[];
        protected int row_length;

        protected Type1Record()
        {
            data = new char[0];