Oracle Coherence for C++ API
Release 3.6.0.0
E15728-01

- Main Page
- Namespaces
- Classes
- Files

# coherence/io/pof/PofBufferWriter.hpp

    00001 /*
    00002 * PofBufferWriter.hpp
    00003 *
    00004 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
    00005 *
    00006 * Oracle is a registered trademarks of Oracle Corporation and/or its
    00007 * affiliates.
    00008 *
    00009 * This software is the confidential and proprietary information of Oracle
    00010 * Corporation. You shall not disclose such confidential and proprietary
    00011 * information and shall use it only in accordance with the terms of the
    00012 * license agreement you entered into with Oracle.
    00013 *
    00014 * This notice may not be removed or altered.
    00015 */
    00016 #ifndef COH_POF_BUFFER_WRITER_HPP
    00017 #define COH_POF_BUFFER_WRITER_HPP
    00018
    00019 #include "coherence/lang.ns"
    00020
    00021 #include "coherence/io/WriteBuffer.hpp"
    00022 #include "coherence/io/pof/PofContext.hpp"
    00023 #include "coherence/io/pof/PofHelper.hpp"
    00024 #include "coherence/io/pof/PofWriter.hpp"
    00025 #include "coherence/io/pof/RawDate.hpp"
    00026 #include "coherence/io/pof/RawDateTime.hpp"
    00027 #include "coherence/io/pof/RawDayTimeInterval.hpp"
    00028 #include "coherence/io/pof/RawTime.hpp"
    00029 #include "coherence/io/pof/RawTimeInterval.hpp"
    00030 #include "coherence/io/pof/RawYearMonthInterval.hpp"
    00031 #include "coherence/io/pof/WritingPofHandler.hpp"
    00032 #include "coherence/util/Binary.hpp"
    00033 #include "coherence/util/Collection.hpp"
    00034 #include "coherence/util/LongArray.hpp"
    00035 #include "coherence/util/Map.hpp"
    00036
    00037 COH_OPEN_NAMESPACE3(coherence,io,pof)
    00038
    00039 using coherence::io::WriteBuffer;
    00040 using coherence::util::Binary;
    00041 using coherence::util::Collection;
    00042 using coherence::util::LongArray;
    00043 using coherence::util::Map;
    00044
    00045
    00046 /**
    00047 * PofWriter implementation that writes POF-encoded data to a
    00048 * WriteBuffer::BufferOutput.
    00049 *
    00050 * @author jh  2008.04.09
    00051 */
    00052 class COH_EXPORT PofBufferWriter
    00053     : public class_spec<PofBufferWriter,
    00054         extends<PofHelper>,
    00055         implements<PofWriter> >
    00056     {
    00057     friend class factory<PofBufferWriter>;
    00058
    00059     // ----- constructors ---------------------------------------------------
    00060
    00061     protected:
    00062         /**
    00063         * Construct a new PofBufferWriter that will write a POF stream to the
    00064         * passed BufferOutput object.
    00065         *
    00066         * @param hOut  the BufferOutput object to write to; must not be NULL
    00067         * @param vCtx  the PofContext used by the new PofBufferWriter to
    00068         *              serialize user types; must not be NULL
    00069         */
    00070         PofBufferWriter(WriteBuffer::BufferOutput::Handle hOut,
    00071                 PofContext::View vCtx);
    00072
    00073         /**
    00074         * Construct a new PofBufferWriter that will write a POF stream using
    00075         * the passed WritingPofHandler.
    00076         *
    00077         * @param hHandler  the WritingPofHandler used for writing; must not
    00078         *                  be NULL
    00079         * @param vCtx      the PofContext used by the new PofBufferWriter to
    00080         *                  serialize user types; must not be NULL
    00081         */
    00082         PofBufferWriter(WritingPofHandler::Handle hHandler,
    00083                 PofContext::View vCtx);
    00084
    00085
    00086     // ----- PofWriter interface --------------------------------------------
    00087
    00088     public:
    00089         /**
    00090         * {@inheritDoc}
    00091         */
    00092         virtual void writeBoolean(int32_t iProp, bool f);
    00093
    00094         /**
    00095         * {@inheritDoc}
    00096         */
    00097         virtual void writeOctet(int32_t iProp, octet_t b);
    00098
    00099         /**
    00100         * {@inheritDoc}
    00101         */
    00102         virtual void writeChar16(int32_t iProp, char16_t ch);
    00103
    00104         /**
    00105         * {@inheritDoc}
    00106         */
    00107         virtual void writeInt16(int32_t iProp, int16_t n);
    00108
    00109         /**
    00110         * {@inheritDoc}
    00111         */
    00112         virtual void writeInt32(int32_t iProp, int32_t n);
    00113
    00114         /**
    00115         * {@inheritDoc}
    00116         */
    00117         virtual void writeInt64(int32_t iProp, int64_t l);
    00118
    00119         /**
    00120         * {@inheritDoc}
    00121         */
    00122         virtual void writeFloat32(int32_t iProp, float32_t fl);
    00123
    00124         /**
    00125         * {@inheritDoc}
    00126         */
    00127         virtual void writeFloat64(int32_t iProp, float64_t dfl);
    00128
    00129         /**
    00130         * {@inheritDoc}
    00131         */
    00132         virtual void writeBooleanArray(int32_t iProp, Array<bool>::View vaf);
    00133
    00134         /**
    00135         * {@inheritDoc}
    00136         */
    00137         virtual void writeOctetArray(int32_t iProp, Array<octet_t>::View vab);
    00138
    00139         /**
    00140         * {@inheritDoc}
    00141         */
    00142         virtual void writeChar16Array(int32_t iProp, Array<char16_t>::View vach);
    00143
    00144         /**
    00145         * {@inheritDoc}
    00146         */
    00147         virtual void writeInt16Array(int32_t iProp, Array<int16_t>::View van);
    00148
    00149         /**
    00150         * {@inheritDoc}
    00151         */
    00152         virtual void writeInt32Array(int32_t iProp, Array<int32_t>::View van);
    00153
    00154         /**
    00155         * {@inheritDoc}
    00156         */
    00157         virtual void writeInt64Array(int32_t iProp, Array<int64_t>::View val);
    00158
    00159         /**
    00160         * {@inheritDoc}
    00161         */
    00162         virtual void writeFloat32Array(int32_t iProp, Array<float32_t>::View vafl);
    00163
    00164         /**
    00165         * {@inheritDoc}
    00166         */
    00167         virtual void writeFloat64Array(int32_t iProp, Array<float64_t>::View vadfl);
    00168
    00169         /**
    00170         * {@inheritDoc}
    00171         */
    00172         virtual void writeBinary(int32_t iProp, Binary::View vBin);
    00173
    00174         /**
    00175         * {@inheritDoc}
    00176         */
    00177         virtual void writeString(int32_t iProp, String::View vs);
    00178
    00179         /**
    00180         * {@inheritDoc}
    00181         */
    00182         virtual void writeRawDate(int32_t iProp, RawDate::View vDate);
    00183
    00184         /**
    00185         * {@inheritDoc}
    00186         */
    00187         virtual void writeRawDateTime(int32_t iProp, RawDateTime::View vdt);
    00188
    00189         /**
    00190         * {@inheritDoc}
    00191         */
    00192         virtual void writeRawDayTimeInterval(int32_t iProp,
    00193                 RawDayTimeInterval::View vInterval);
    00194
    00195         /**
    00196         * {@inheritDoc}
    00197         */
    00198         virtual void writeRawTime(int32_t iProp, RawTime::View vTime);
    00199
    00200         /**
    00201         * {@inheritDoc}
    00202         */
    00203         virtual void writeRawTimeInterval(int32_t iProp,
    00204                 RawTimeInterval::View vInterval);
    00205
    00206         /**
    00207         * {@inheritDoc}
    00208         */
    00209         virtual void writeRawYearMonthInterval(int32_t iProp,
    00210                 RawYearMonthInterval::View vInterval);
    00211
    00212         /**
    00213         * {@inheritDoc}
    00214         */
    00215         virtual void writeObject(int32_t iProp, Object::View v);
    00216
    00217         /**
    00218         * {@inheritDoc}
    00219         */
    00220         virtual void writeObjectArray(int32_t iProp, ObjectArray::View va);
    00221
    00222         /**
    00223         * {@inheritDoc}
    00224         */
    00225         virtual void writeObjectArray(int32_t iProp, ObjectArray::View va,
    00226                 Class::View vClass);
    00227
    00228         /**
    00229         * {@inheritDoc}
    00230         */
    00231         virtual void writeLongArray(int32_t iProp, LongArray::View vla);
    00232
    00233         /**
    00234         * {@inheritDoc}
    00235         */
    00236         virtual void writeLongArray(int32_t iProp, LongArray::View vla,
    00237                 Class::View vClass);
    00238
    00239         /**
    00240         * {@inheritDoc}
    00241         */
    00242         virtual void writeCollection(int32_t iProp, Collection::View vCol);
    00243
    00244         /**
    00245         * {@inheritDoc}
    00246         */
    00247         virtual void writeCollection(int32_t iProp, Collection::View vCol,
    00248                 Class::View vClass);
    00249
    00250         /**
    00251         * {@inheritDoc}
    00252         */
    00253         virtual void writeMap(int32_t iProp, Map::View vMap);
    00254
    00255         /**
    00256         * {@inheritDoc}
    00257         */
    00258         virtual void writeMap(int32_t iProp, Map::View vMap,
    00259                 Class::View vClassKey);
    00260
    00261         /**
    00262         * {@inheritDoc}
    00263         */
    00264         virtual void writeMap(int32_t iProp, Map::View vMap,
    00265                 Class::View vClassKey, Class::View vClassValue);
    00266
    00267         /**
    00268         * {@inheritDoc}
    00269         */
    00270         virtual PofContext::View getPofContext() const;
    00271
    00272         /**
    00273         * {@inheritDoc}
    00274         */
    00275         virtual void setPofContext(PofContext::View vCtx);
    00276
    00277         /**
    00278         * {@inheritDoc}
    00279         */
    00280         virtual int32_t getUserTypeId() const;
    00281
    00282         /**
    00283         * {@inheritDoc}
    00284         */
    00285         virtual int32_t getVersionId() const;
    00286
    00287         /**
    00288         * {@inheritDoc}
    00289         */
    00290         virtual void setVersionId(int32_t nVersionId);
    00291
    00292         /**
    00293         * {@inheritDoc}
    00294         */
    00295         virtual void writeRemainder(Binary::View vBinProps);
    00296
    00297
    00298     // ----- internal methods -----------------------------------------------
    00299
    00300     protected:
    00301         /**
    00302         * Report that a POF property is about to be written to the POF
    00303         * stream.
    00304         *
    00305         * This method call will be followed by one or more separate calls to
    00306         * a "write" method and the property extent will then be terminated by
    00307         * a call to {@link #endProperty}.
    00308         *
    00309         * @param iProp  the index of the property being written
    00310         *
    00311         * @throws IllegalArgumentException  if the property index is invalid,
    00312         *         or is less than or equal to the index of the previous
    00313         *         property written to the POF stream
    00314         * @throws IOException  if an I/O error occurs
    00315         */
    00316         virtual void beginProperty(int32_t iProp);
    00317
    00318         /**
    00319         * Signifies the termination of the current POF property.
    00320         *
    00321         * @param iProp  the index of the current property
    00322         */
    00323         virtual void endProperty(int32_t iProp);
    00324
    00325         /**
    00326         * Assert that a class is equal to another class.
    00327         *
    00328         * @param vClass      the expected class; must not be NULL
    00329         * @param vClassTest  the class to test for equality; must not be NULL
    00330         *
    00331         * @throws IllegalStateException if the second class is not equal to
    00332         *         the first
    00333         */
    00334         static void assertEqual(Class::View vClass, Class::View vClassTest);
    00335
    00336
    00337     // ----- accessors ------------------------------------------------------
    00338
    00339     protected:
    00340         /**
    00341         * Return the BufferOutput that this PofBufferWriter writes to.
    00342         *
    00343         * @return the BufferOutput
    00344         */
    00345         virtual WriteBuffer::BufferOutput::Handle getBufferOutput();
    00346
    00347         /**
    00348         * Return the BufferOutput that this PofBufferWriter writes to.
    00349         *
    00350         * @return the BufferOutput
    00351         */
    00352         virtual WriteBuffer::BufferOutput::View getBufferOutput() const;
    00353
    00354         /**
    00355         * Return the WritingPofHandler used internally by this
    00356         * PofBufferWriter to write the POF stream.
    00357         *
    00358         * @return the PofHandler
    00359         */
    00360         virtual WritingPofHandler::Handle getPofHandler();
    00361
    00362         /**
    00363         * Return the WritingPofHandler used internally by this
    00364         * PofBufferWriter to write the POF stream.
    00365         *
    00366         * @return the PofHandler
    00367         */
    00368         virtual WritingPofHandler::View getPofHandler() const;
    00369
    00370
    00371     // ----- data members ---------------------------------------------------
    00372
    00373     protected:
    00374         /**
    00375         * The BufferOutput object that the PofBufferWriter writes to.
    00376         */
    00377         FinalHandle<WriteBuffer::BufferOutput> m_hOut;
    00378
    00379         /**
    00380         * The PofContext used by this PofBufferWriter to serialize user types.
    00381         */
    00382         MemberView<PofContext> m_vCtx;
    00383
    00384         /**
    00385         * The WritingPofHandler used to write a POF stream.
    00386         */
    00387         FinalHandle<WritingPofHandler> m_hHandler;
    00388     };
    00389
    00390 COH_CLOSE_NAMESPACE3
    00391
    00392 #endif // COH_POF_BUFFER_WRITER_HPP

Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.