Beispiel #1
0
        } // End of ImplWriteValue (...)

        protected virtual void ImplWriteValue(TextWriter tw, IEnumerable value)
        {
            tw.Write('[');

            if (value != null)
            {
                String     itemSep = String.Empty;
                IValueUnit vu      = null;

                foreach (Object item in value)
                {
                    tw.Write(itemSep);

                    if ((vu = item as IValueUnit) != null)
                    {
                        _Write(tw, vu);
                    }
                    else
                    {
                        ImplDispatchWriteValue(tw, item);
                    }

                    itemSep = ",";
                }
            }

            tw.Write(']');
        } // End of ImplWriteValue (...)
Beispiel #2
0
        private void _Write(TextWriter tw, IValueUnit valueUnit)
        {
            tw.Write('{');

            String     itemSep = String.Empty;
            IValueUnit subUnit = null;

            foreach (IValueItem valueItem in valueUnit)
            {
                tw.Write(itemSep);
                tw.Write('"');
                tw.Write(valueItem.Key);
                tw.Write('"');
                tw.Write(':');

                if ((subUnit = valueItem.Value as IValueUnit) == null)
                {
                    ImplDispatchWriteValue(tw, valueItem.Value);
                }
                else
                {
                    _Write(tw, subUnit);
                }

                itemSep = ",";
            }

            tw.Write('}');
        } // End of _Write (...)
Beispiel #3
0
        protected override InterfaceType ImplDeserialize(
            IValueUnit valueUnit, IRepositorySerializationContext context)
        {
            if (valueUnit == null)
            {
                return(default(InterfaceType));
            }

            IValueUnit ctxVu = null;
            IValueUnit tmpVu = valueUnit;
            IValueItem tmpVi = null;

            if (tmpVu.Count == 2 && context.Metadata == context.Hierarchy.Peek())
            {
                if ((tmpVi = tmpVu ["$Metadata"]) != null &&
                    (ctxVu = tmpVi.Value as IValueUnit) != null &&
                    (tmpVi = tmpVu ["$Data"]) != null &&
                    (tmpVu = tmpVi.Value as IValueUnit) != null)
                {
                    valueUnit = tmpVu;

                    if (context.Metadata.Count == 0)
                    {
                        foreach (IValueItem ctxItem in ctxVu)
                        {
                            context.Metadata.Add(ctxItem.Key, ctxItem.Value);
                        }
                    }
                }
            }

            return(base.ImplDeserialize(valueUnit, context));
        } // End of ImplDeserialize (...)
Beispiel #4
0
        } // End of ImplRead (...)

        protected override void ImplWrite(TextWriter tw, IValueUnit root)
        {
            if (tw == null)
            {
                return;
            }
            if (root == null)
            {
                return;
            }

            _Write(tw, root);
        } // End of ImplWrite (...)
Beispiel #5
0
        } // End of ImplParseUnit (...)

        protected override IValueUnit ImplRead(TextReader textReader)
        {
            IValueUnit retVal = null;

            JsonScanner.TokenBase token = JsonScanner.Singleton.ScanToken(textReader);

            if (token != JsonScanner.CurlyOpenToken.Singleton)
            {
                return(null); // Unespected token
            }
            retVal = ImplParseUnit(out token, textReader);

            return(token == JsonScanner.CurlyCloseToken.Singleton ? retVal : null);
        } // End of ImplRead (...)
Beispiel #6
0
        protected override void ImplSerialize(out IValueUnit retVal, InterfaceType instance, SerializationContextType context)
        {
            IHierarchicalMetadataProvider <IValueUnit, IValueItemBase> ctx = null;
            IValueUnit curCtxLvl = null;

            ctx       = context as IHierarchicalMetadataProvider <IValueUnit, IValueItemBase>;
            curCtxLvl = ctx.Hierarchy.Peek() as IValueUnit;

            if (curCtxLvl != null && ctx != null && ctx.Metadata != null)
            {
                curCtxLvl.Add("SerializationManager", GetType().AssemblyQualifiedName);
            }

            retVal = ImplFactory.Serialize(instance, context);
        } // End of ImplSerialize (...)
        protected override void ImplWrite (
            TextWriter tw, IValueUnit source, IRepositorySerializationContext context )
        {
            if ( context.SerializeMetadata && context.Metadata != null )
                if ( source == null )
                    source = context.Metadata as IValueUnit;
                else
                {
                    IValueUnit wrapperVu = new ValueUnit ();

                    wrapperVu.Add ( "$Metadata", context.Metadata );
                    wrapperVu.Add ( "$Data", source );

                    source = wrapperVu;
                }

            base.ImplWrite ( tw, source, context );
        } // End of ImplWrite (...)
        } // End of ImplSerializeEnumerable (...)

        protected virtual Boolean ImplSerializeItem(
            out Object serializedItem,
            Action contextPrologDlg,
            Action contextEpilogDlg,
            Object itemValue,
            IHierarchicalMetadataSerializationContext context)
        {
            IValueUnit ctxUnit = null;
            IValueUnit subUnit = null;

            if ((ctxUnit = context.Hierarchy.Peek() as IValueUnit) == null)
            {
                serializedItem = null;

                return(false);
            }

            if (ImplIsBuiltinType(itemValue.GetType()))
            {
                /* ctxts.Add ( null ); */ serializedItem = itemValue;
            }
            else if (ImplIsString(itemValue.GetType()))
            {
                /* ctxts.Add ( null ); */ serializedItem = itemValue;
            }
            //else if ( ImplSerializeEnumerable ( retVal, pd.Name, item as IEnumerable, context ) )
            //    continue;
            else if (ImplSerializeObject(
                         out subUnit,
                         contextPrologDlg,
                         contextEpilogDlg,
                         itemValue, //as IValueObjectContract,
                         context))
            {
                serializedItem = subUnit;
            }
            else
            {
                serializedItem = null;
            }

            return(true);
        } // End of ImplSerializeItem (...)
Beispiel #9
0
        } // End of ImplSerialize (...)

        protected override InterfaceType ImplDeserialize(IValueUnit valueUnit, SerializationContextType context)
        {
            IValueUnit curCtxLvl = null;
            SerializationManager <InterfaceType,
                                  AdapterType,
                                  IValueUnit,
                                  SerializationContextType,
                                  MyselfType> repoSerMgr = null;
            IValueItem valueItem = null;

            if ((curCtxLvl = context.Hierarchy.Peek() as IValueUnit) == null)
            {
                return(default(InterfaceType));
            }

            valueItem = curCtxLvl ["SerializationManager"] as IValueItem;

            if (valueItem != null)
            {
                if (GetType().AssemblyQualifiedName.Equals(valueItem.Value))
                {
                    return(base.ImplDeserialize(valueUnit, context));
                }
                else
                {
                    repoSerMgr = Activator.CreateInstance(Type.GetType(valueItem.Value.ToString()))
                                 as SerializationManager <InterfaceType,
                                                          AdapterType,
                                                          IValueUnit,
                                                          SerializationContextType,
                                                          MyselfType>;

                    if (repoSerMgr != null)
                    {
                        return(repoSerMgr.Deserialize(valueUnit, context));
                    }
                }
            }

            return(default(InterfaceType));
        } // End of ImplDeserialize (...)
        } // End  of ImplDeserializeItem (...)

        protected virtual Type ImplGetItemType(IHierarchicalMetadataSerializationContext context)
        {
            if (context == null)
            {
                return(null);
            }

            IValueItem itemCtxtVi = null;
            IValueUnit itemCtxtVu = context.Hierarchy.Peek() as IValueUnit;

            if (itemCtxtVu == null)
            {
                return(null);
            }
            if ((itemCtxtVi = itemCtxtVu ["TypeGuid"]) == null)
            {
                return(null);
            }

            GuidTypeMapping.Item tmp = GuidTypeMapping.Singleton [
                new Guid(itemCtxtVi.Value as String)];

            return(tmp == null ? null : tmp.Type);
        } // End of ImplGetItemType (...)
        //protected override Boolean ImplAddSequenceItem ( SequenceType sequence, Object item )
        //{
        //    if ( !(item is SequenceItemType) ) return false;

        //    SequenceItemType kvp = (SequenceItemType) item;

        //    try { sequence.Add ( kvp.Key, kvp.Value ); }
        //    catch { return false; }

        //    return true;
        //} // End of ImplAddSequenceItem (...)

        protected override Boolean ImplDeserializeItem(
            out Object retVal,
            Object item,
            IHierarchicalMetadataSerializationContext context)
        {
            retVal = null;

            IValueItem curCtxtLvlVi = null;
            KeyValuePair <SequenceKeyType,
                          SequenceValueType> kvp;
            IValueUnit        kvpVu;
            IValueUnit        kvpCtxtLvl = null;
            SequenceKeyType   kvpKey     = default(SequenceKeyType);
            SequenceValueType kvpValue   = default(SequenceValueType);
            IValueItem        valueItem  = null;

            if (context == null)
            {
                return(false);
            }
            if ((kvpVu = item as IValueUnit) == null)
            {
                return(false);
            }
            if (kvpVu.Count != 2)
            {
                return(false);
            }
            if ((kvpCtxtLvl = context.Hierarchy.Peek() as IValueUnit) == null)
            {
                return(false);
            }

            // Deserialize the Key
            if ((valueItem = kvpVu [nameof(kvp.Key)]) == null)
            {
                return(false);
            }

            if ((curCtxtLvlVi = kvpCtxtLvl [nameof(kvp.Key)]) == null)
            {
                context.Hierarchy.Push(null);
            }
            else
            {
                context.Hierarchy.Push(curCtxtLvlVi.Value as IValueUnit);
            }

            try
            {
                if (!base.ImplDeserializeItem(out Object key, valueItem.Value, context))
                {
                    return(false);
                }

                kvpKey = (SequenceKeyType)key;
            } finally { context.Hierarchy.Pop(); }


            // Deserialize the Value
            if ((valueItem = kvpVu [nameof(kvp.Value)]) == null)
            {
                return(false);
            }

            if ((curCtxtLvlVi = kvpCtxtLvl [nameof(kvp.Value)]) == null)
            {
                context.Hierarchy.Push(null);
            }
            else
            {
                context.Hierarchy.Push(curCtxtLvlVi.Value as IValueUnit);
            }

            try
            {
                if (!base.ImplDeserializeItem(out Object value, valueItem.Value, context))
                {
                    return(false);
                }

                kvpValue = (SequenceValueType)value;
            } finally { context.Hierarchy.Pop(); }

            kvp    = new KeyValuePair <SequenceKeyType, SequenceValueType> (kvpKey, kvpValue);
            retVal = kvp;

            return(true);
        } // End of ImplDeserializeItem (...)
Beispiel #12
0
 public RepositorySerializationContext(IValueUnit metadata) : base(metadata)
 {
 }
 protected CompositedIdObject(IValueUnit valueUnit,
                              IHierarchicalMetadataSerializationContext context)
     : base(valueUnit, context)
 {
     _Reset();
 }
Beispiel #14
0
        } // End of Class ContainedObjectFactory


        protected override IContainedObject ImplDeserialize<SerializationContextType> (
            IValueUnit                  serialization,
            SerializationContextType    context )
        => new ContainedObject ( serialization, context as IHierarchicalMetadataSerializationContext );
Beispiel #15
0
 public DerivedObject    (   IValueUnit                                  valueUnit,
                             IHierarchicalMetadataSerializationContext   context )
     : base ( valueUnit, context ) { }
Beispiel #16
0
        } // End of Custom Constructor

        protected Entity(IValueUnit valueUnit,
                         IHierarchicalMetadataSerializationContext context)
            : base(valueUnit, context)
        {
        }
        protected override Boolean ImplSerializeEnumerable(
            out ArrayList values,
            IEnumerable objValue,
            IHierarchicalMetadataSerializationContext context)
        {
            values = new ArrayList();

            if (objValue == null)
            {
                return(false);
            }
            if (context == null)
            {
                return(false);
            }

            IValueSequence valueSeq = context.Hierarchy.Peek() as IValueSequence;

            if (valueSeq == null)
            {
                return(false);
            }

            IList ctxts = valueSeq.Value as IList;

            if (ctxts == null)
            {
                return(false);
            }

            IValueUnit ctxUnit  = null;
            Type       instType = null;

            context.Hierarchy.Pop();

            if ((ctxUnit = context.Hierarchy.Peek() as IValueUnit) == null)
            {
                return(false);
            }

            // Add SerMgr key
            if ((instType = typeof(SequenceType)).IsGenericType)
            {
                ctxUnit.Add("SerializationManager",
                            GetType().GetGenericTypeDefinition().AssemblyQualifiedName);

                ArrayList typeParamGuids = new ArrayList();

                foreach (Type par in instType.GenericTypeArguments)
                {
                    typeParamGuids.Add(par.GetTypeGuid().ToString());
                }

                ctxUnit.Add("SerializationManagerInstanceTypeParamGuids",
                            new ValueSequence(typeParamGuids));
            }
            else
            {
                return(false);// ctxUnit.Add ( "SerializationManager", instType.AssemblyQualifiedName );
            }
            context.Hierarchy.Push(valueSeq);

            foreach (KeyValuePair <SequenceKeyType, SequenceValueType> kvp in objValue)
            {
                ValueUnit kvpValueUnit = new ValueUnit();
                Object    tmpValue     = null;

                ctxts.Add(ctxUnit = new ValueUnit());

                context.Hierarchy.Push(ctxUnit);

                ImplSerializeItem(
                    out tmpValue,
                    //delegate ( IValueUnit vu ) { ctxUnit.Add ( nameof ( kvp.Key ), vu ); },
                    delegate() {
                    ValueUnit vu = new ValueUnit();

                    ctxUnit.Add(nameof(kvp.Key), vu);
                    context.Hierarchy.Push(vu);
                },
                    delegate() { context.Hierarchy.Pop(); },
                    kvp.Key,
                    context);

                kvpValueUnit.Add(new ValueItem(nameof(kvp.Key), tmpValue));

                ImplSerializeItem(
                    out tmpValue,
                    //delegate ( IValueUnit vu ) { ctxUnit.Add ( nameof ( kvp.Value ), vu ); },
                    delegate() {
                    ValueUnit vu = new ValueUnit();

                    ctxUnit.Add(nameof(kvp.Value), vu);
                    context.Hierarchy.Push(vu);
                },
                    delegate() { context.Hierarchy.Pop(); },
                    kvp.Value,
                    context);

                kvpValueUnit.Add(new ValueItem(nameof(kvp.Value), tmpValue));

                values.Add(kvpValueUnit);

                context.Hierarchy.Pop();
            }

            return(true);
        } // End of ImplSerializeEnumerable (...)
        protected virtual Boolean ImplDeserializeItem <ContextType> (
            out Object retVal,
            Object item,
            Func <IValueItemBase> getCurrentContextDlg,
            ContextType context)
            where ContextType : ISerializationContext
        {
            retVal = null;

            //Type                                            itemType        = null;
            //NumericStringValue                              numericString   = null;
            IConvertibleString         cnvStr = null;
            ISerializable <IValueUnit> serMgr = null;
            ValueDomObjectSerializationManagerCollection serMgrColl = null;
            ObjectSerializationManagerDescr serMgrDescr             = null;
            IValueUnit subCtxtLvl = null;
            IValueUnit subUnit    = null;
            String     typeName   = null;
            IValueItem valueItem  = null;

            if (item == null)
            {
                retVal = null;
            }
            else if (ImplIsBuiltinType(item.GetType()))
            {
                retVal = item;
            }
            //else if ( ImplIsString ( item.GetType () ) )
            //    if ( (itemType = ImplGetItemType ( context )) == null )
            //        retVal = item;
            //    else if ( itemType == typeof ( String ) )
            //        retVal = item;
            //    else
            //        retVal = ImpConvertToType ( item, itemType );
            //else if ( (numericString = item as NumericStringValue) != null )
            //    retVal = ImpConvertToType ( numericString, ImplGetItemType ( context ) );
            else if (ImplIsString(item.GetType()))
            {
                retVal = ImpConvertToType(item, ImplGetItemType(context));
            }
            else if ((cnvStr = item as IConvertibleString) != null)
            {
                retVal = ImpConvertToType(cnvStr, ImplGetItemType(context));
            }
            else if ((subUnit = item as IValueUnit) == null)
            {
                return(false);
            }
            //propValue = pd.GetValue ( InitDto );

            //if ( _DeserializeEnumerable ( ref propValue, pd, valueItem.Value, context ) )
            //    continue;
            //else
            //    propValue = valueItem.Value;
            else if (getCurrentContextDlg == null)
            {
                return(false);
            }
            else if ((subCtxtLvl = getCurrentContextDlg() as IValueUnit) == null)
            {
                return(false);
            }
            else if ((valueItem = subCtxtLvl ["SerializationManager"] as IValueItem) == null)
            {
                return(false);
            }
            else if (valueItem.Value == null)
            {
                return(false);
            }
            else if ((typeName = valueItem.Value.ToString()) == null)
            {
                return(false);
            }
            else if ((serMgrColl = ValueDomObjectSerializationManagerCollection.Singleton) == null)
            {
                return(false);
            }
            else if ((serMgrDescr = serMgrColl [typeName]) == null)
            {
                return(false);
            }
            else if ((serMgr = serMgrDescr.SerializationManager) == null)
            {
                return(false);
            }
            else
            {
                retVal = serMgr.Deserialize(subUnit, context);
            }

            return(true);
        } // End  of ImplDeserializeItem (...)
        } // End of ImplSerializeEnumerable (...)

        protected virtual Boolean ImplSerializeEnumerable(
            out ArrayList values,
            IEnumerable objValue,
            IHierarchicalMetadataSerializationContext context)
        {
            values = new ArrayList();

            if (objValue == null)
            {
                return(false);
            }
            if (context == null)
            {
                return(false);
            }

            IValueSequence valueSeq = context.Hierarchy.Peek() as IValueSequence;

            if (valueSeq == null)
            {
                return(false);
            }

            IList ctxts = ((IValueItemBase)valueSeq).Value as IList;

            if (ctxts == null)
            {
                return(false);
            }

            IValueUnit ctxUnit    = null;
            Type       itemType   = null;
            Type       serMgrType = null;
            IValueUnit subUnit    = null;

            context.Hierarchy.Pop();

            try
            {
                if ((ctxUnit = context.Hierarchy.Peek() as IValueUnit) == null)
                {
                    return(false);
                }
                else if ((serMgrType = GetType()).IsGenericType)
                {
                    ctxUnit.Add("SerializationManager",
                                serMgrType.GetGenericTypeDefinition().AssemblyQualifiedName);

                    ArrayList typeParamGuids = new ArrayList();

                    foreach (Type par in serMgrType.GenericTypeArguments)
                    {
                        typeParamGuids.Add(par.GetTypeGuid().ToString());
                    }

                    ctxUnit.Add("SerializationManagerInstanceTypeParamGuids",
                                new ValueSequence(typeParamGuids));
                }
                else
                {
                    ctxUnit.Add("SerializationManager", serMgrType.AssemblyQualifiedName);
                }
            }
            finally { context.Hierarchy.Push(valueSeq); }

            foreach (Object item in objValue)
            {
                if (ImplIsBuiltinType(itemType = item.GetType()))
                {
                    ValueUnit vu = new ValueUnit();

                    vu.Add(new ValueItem("TypeGuid", itemType.GetTypeGuid().ToString()));
                    ctxts.Add(vu);
                    values.Add(item);
                }
                else if (ImplIsString(item.GetType()))
                {
                    ctxts.Add(null); values.Add(item);
                }
                //else if ( ImplSerializeEnumerable ( retVal, pd.Name, item as IEnumerable, context ) )
                //    continue;
                else if (ImplSerializeObject(
                             out subUnit,
                             //delegate ( IValueUnit vu ) { ctxts.Add ( vu ); },
                             delegate() {
                    ValueUnit vu = new ValueUnit();

                    ctxts.Add(vu);
                    context.Hierarchy.Push(vu);
                },
                             delegate() { context.Hierarchy.Pop(); },
                             item, //as IValueObjectContract,
                             context))
                {
                    values.Add(subUnit);
                }
            }

            return(true);
        } // End of ImplSerializeEnumerable (...)