Serializable.hxx

Go to the documentation of this file.

#ifndef COMMON_SERIALIZABLE_H
#define COMMON_SERIALIZABLE_H

/*
 * Copyright (c) 2004, The EROS Group, LLC and Johns Hopkins
 * University. All rights reserved.
 * 
 * This software was developed to support the EROS secure operating
 * system project (http://www.eros-os.org). The latest version of
 * the OpenCM software can be found at http://www.opencm.org.
 * 
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 * 
 * 3. Neither the name of the The EROS Group, LLC nor the name of
 *    Johns Hopkins University, nor the names of its contributors
 *    may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

class Repository;
class MarkState;

/* Serializable -- all serializable entities obey this protocol */

#define OBTYPE(code,ver,schema,nm) TY_##nm = code,
enum SerTypeConst {
#include "OBTYPES.def"
  
  TY_ntypes,
  TY_Serializable    /* means any Serializable object */
};

/* The serializable metaVersion field appears at the location where
   the obVer used to appear before the metaVersion field was
   introduced. At that time, the highest object version was
   1. We therefore set FIRST_METAVERSION to 2.

   If we retrieve an object whose metaVer field claims to be <
   FIRST_METAVERSION, then the field retrieved is really an object
   version. In that case, the metaversion is understood to be 0 and
   the affinity is also 0. */
#define SERIALIZABLE_FIRST_METAVERSION 4
#define SERIALIZABLE_CURRENT_METAVERSION 4
/* Last metaversion where we did a major schema change */
#define SERIALIZABLE_CURRENT_SCHEMA_METAVERSION 4

struct SerialType;              // forward declaration
struct Buffer;                  // forward declaration

/* Forward declarations: */
namespace sdr {
  class OStream;
  class IStream;
};

struct Serializable : public Countable {
  friend class SerMeta;

public:
  const SerialType *serType;
  uint32_t metaVer;             /* version of the Serializable structure */
  uint32_t   obVer; /* serialized version constant for this object */

  /* Beginning in metaVer 2 */
  uint32_t affinity;            /* storage affinity */

  /* Following fields are in-memory only: */
  bool        canFreeze;
private:
  TrueName    trueName;

public:
  /* This constructor is used solely for the global, static
     declarations of prototypical SerialType templates. */
  inline Serializable(const SerialType* st, uint32_t mv, uint32_t ov)
    : serType(st)
  {
    metaVer = mv;
    obVer = ov;
    affinity = 0;

    canFreeze = false;
    trueName = TrueName::Null;
  }

  Serializable(const Serializable& other)
  {
    serType = other.serType;
    metaVer = other.metaVer;
    obVer = other.obVer;
    affinity = other.affinity;
    canFreeze = false;
    trueName = TrueName::Null;
  }

  virtual ~Serializable()
  {
  }

  inline SerTypeConst getType() const;

  TrueName getTrueName() const;
  TrueName getTrueName();

  GCPtr<Serializable> deepCopy() const;

  inline void SetAffinity(uint32_t aff)
  {
    affinity = aff;
  }

  inline uint32_t GetAffinity()
  {
    return affinity;
  }

  void toBuffer(Buffer& buf, bool forSignature = false);

public:
  // These are intended to be used only by the low-level 
  // serialization routines. 
  void serialize_meta(sdr::OStream& strm) const;
  void deserialize_meta(sdr::IStream &strm);
};

struct SerialType {
  const SerTypeConst tyConst;   /* type code */

  /* This serializable is used as a template when creating new
     objects. Its version field contains the highest known version,
     and its ser_type field points back recursively to the containing
     SerialType structure */
  const Serializable& ser;

  const char *  tyName;         /* used in texty formats */

  static const SerialType* find(SerTypeConst tyConst);

  void (*serialize)(sdr::OStream& os, GCPtr<const Serializable> s);
  GCPtr<Serializable> (*deserialize)(sdr::IStream&, const Serializable &meta);
  void          (*mark)        (GCPtr<Repository>,
                                GCPtr<const Serializable> container,
                                GCPtr<const Serializable> ob,
                                MarkState& memObs);
  bool          (*check)       (GCPtr<const Serializable> ob);
};

inline SerTypeConst Serializable::getType() const
{
  return serType->tyConst;
}

/* The following declarations are common to all serializable
   objects. Rather than encourage keystroke and update errors, provide
   a macro here that can be used at the front of every object
   declaration to get them all:
 */
#define SERIALIZABLE_DECLS(typename) \
public: \
  static void serialize(sdr::OStream& os, GCPtr<const Serializable> s); \
  static GCPtr<Serializable> deserialize(sdr::IStream&, const Serializable &meta); \
  static void mark(GCPtr<Repository> r, \
                   GCPtr<const Serializable> container, \
                   GCPtr<const Serializable> ob, \
                   MarkState& memObs); \
  static bool check(GCPtr<const Serializable> ob); \
\
  static const SerialType SerType; \
  static const Serializable CurMeta; \
\
  typename(const Serializable& s = CurMeta); \
  virtual ~typename()


/* It is occasionally useful to extract and save/restore just the
   metadata of an object: */
typedef struct SerMeta SerMeta;
struct SerMeta : public Serializable {
  SERIALIZABLE_DECLS(SerMeta);

  Serializable meta;

  static GCPtr<SerMeta> fromSerializable(GCPtr<const Serializable>);
};

#define ser_mark(r, pv, v, ms) v->serType->mark(r, pv, v, ms)

void mark_truename(GCPtr<const Serializable> ob, MarkState& ms, TrueName tn);
void mark_mutname(GCPtr<const Serializable> ob, MarkState& ms, MutName mutName);

#if 0
void ser_init(void *s, const Serializable *);


/* Support for assignment guards: */
#define CMVAR(x) cm_##x
#define CMCHANGED(s1)   ( ((Serializable *)s1)->trueName.tnval = 0 )
#define CMSET(s1,x,v)   ( CMCHANGED(s1), s1->CMVAR(x) = (v)    )
#define CMGET(s,x)     s->CMVAR(x)
#define CMCLOBBER(s,x) (CMCHANGED(s), s->CMVAR(x))
#define CM_CANFREEZE(s) ((Serializable *)s)->canFreeze = FALSE

/* Support for affinity */
#define AFFGET(s) (((Serializable *)s)->affinity)
#define AFFSET(s,a) (AFFGET(s) = a)
#endif

// Local Variables:
// mode:c++
// End:

#endif /* COMMON_SERIALIZABLE_H */

---