[mapserver-dev] Re: [MAPSERVER-USERS] MapFile2XML conversion - WAS:
mapObjectserialization in C# (variant)
Tamas Szekeres
szekerest at gmail.com
Wed Jun 11 17:36:11 EDT 2008
Bob,
Here`s a demo example to show what the XML writer would do:
typedef struct object_info {
char* name; // may be the corresponding mapfile item name
void* value; // reference to the object or value (string)
char* type; // type of the item
bool isValueType;
int index;
} objectInfo;
int WriteObjectAsXML(objectInfo i, msIOContext *context)
{
char buffer[1024];
objectInfo s;
if (i.isValueType)
{
sprintf(buffer, "<%s type=%s>%s</%s>", i.name, i.type,
(char*)i.value, i.name);
msIO_contextWrite(context, buffer, strlen(buffer));
}
else
{
sprintf(buffer, "<%s type=%s>", i.name, i.type);
msIO_contextWrite(context, buffer, strlen(buffer));
while (s = GetNextSubItem(i))
WriteObjectAsXML(s, context);
sprintf(buffer, "</%s>", i.name);
msIO_contextWrite(context, buffer, strlen(buffer));
}
}
int WriteMapAsXML(mapObj map, msIOContext *context)
{
objectInfo i, s;
i.name = "MAP"
i.value = map;
i.type = "mapObj";
WriteObjectAsXML(i, context);
}
However I don`t think that all of the possible issues have been taken
into account. Just for something to think about.
Best regards,
Tamas
2008/6/11 Bob Basques <Bob.Basques at ci.stpaul.mn.us>:
> Tamas,
>
> I know this would be easier to add after an XML conversion process were
> arrived at, but it's going further than what I was intending, at least in
> the near term.
>
> It does get me thinking about things in more detail though, how would your
> ideas translate into the XML itself, I mean would there be things that would
> be bad to use in the XML that might mitigate these ideas?
>
> I subscribed to the DEV list, but no Email confirmation yet.
>
> bobb
>
>>>> "Tamas Szekeres" <szekerest at gmail.com> wrote:
> Hi Bob and All,
>
> I would support having an interface in mapserver that would provide
> low level access to the object hierarchy, like:
>
> typedef struct object_info {
> char* name;
> void* value;
> char* type;
> int index;
> } objectInfo;
>
> objectInfo* GetNextSubItem(objectInfo* object);
>
> By using this, each persistence provider (MapFile/XML/JSON) could go
> through the object hierarchy easily
> In order to support reading the files, the mapObj properties in the
> hierarchy could also be set in an unique manner, like:
>
> int AddSubItem(objectInfo parent, objectInfo child);
>
> We should also utilize an msIO like functionality so that the
> providers would support reading from and writing to various kind of
> streams/storage types.
>
> We should probably switch to the -dev list with further implementation
> details.
>
> Best regards,
>
> Tamas
>
>
>
> 2008/6/10 Bob Basques <Bob.Basques at ci.stpaul.mn.us>:
>> All,
>>
>> We've been pondering some sort of alternative to the Mapfiles for a few
>> years now. A preferable approach would be something that could be stored
>> in
>> a DB in some fashion for querying/assembly processes. It seems on the
>> surface like a DB schema could be developed to handle the MapFile storage
>> aspects.
>>
>> A first step would be in how to best approach moving into an XML way of
>> life
>> for the MapFiles. Would it make any sense in the beginning to just build
>> a
>> MapFile2XML convertor (I would imagine this would be needed before anyone
>> would sign up for XML) and once something like this is a state close to
>> production, the innards of MapServer would then be made to parse the XML
>> directly?
>>
>> Another approach might be to do something like MapFile2SQL first, and then
>> the MapFile2XML. This might save some time and seem like it would make
>> standardization easier, since it would need to be inside of the DB fist.
>>
>> Has anyone tried putting together any requirements list along these lines
>> at
>> all? Is it going to be something where we just need to jump in and build
>> something even if it might be a wrong approach to begin with?
>>
>> This thread just got me thinking is all . . .you know how dangerous that
>> can
>> be . . . :c)
>>
>> bobb
>>
>>
>>>>> "Tamas Szekeres" <szekerest at gmail.com> wrote:
>> Hi,
>>
>> MapServer currently doesn`t support any other persitence
>> representation than the mapfiles. There have been some initial plans
>> related to an XML format in this list, but no one had any motivation
>> to implement that.
>> So I think the best what you can do at the moment is to use reflection
>> to access the properties along with some other members of the objects
>> and serialize the values manually.
>>
>> Best regards,
>>
>> Tamas
>>
>>
>> 2008/6/9 BrainDrain <paulborodaev at gmail.com>:
>>>
>>> Is there any 'standart' fast(!) way/method to serialize (xml/json/other
>>> markup) mapObj in C#? I need it for using server mapObj as JSON on rich
>>> client app running on browser. Look at my method (using reflection):
>>>
>>> public static ListDictionary PartialSerialize(object instance, Stack
>>> callerTypes, Type[] excludeTypes)
>>> {
>>> ListDictionary result = new ListDictionary();
>>> object val;
>>>
>>> callerTypes.Push(instance.GetType());
>>> PropertyInfo[] pis = instance.GetType().GetProperties();
>>> foreach (PropertyInfo pi in pis)
>>> {
>>> if (pi.PropertyType.IsSerializable &&
>>> !pi.PropertyType.IsArray)
>>> result[pi.Name] = pi.GetValue(instance, new
>>> object[0]);
>>> else
>>> {
>>> //preventing useless nesting
>>> if (!callerTypes.Contains(pi.PropertyType) &&
>>> !((IList)excludeTypes).Contains(pi.PropertyType))
>>> {
>>> val = pi.GetValue(instance, new object[0]);
>>> if (val != null)
>>> result[pi.Name] = PartialSerialize(val,
>>> callerTypes, excludeTypes);
>>> }
>>> }
>>> }
>>> callerTypes.Pop();
>>> return result;
>>> }
>>> ...
>>> So I can convert mapObj on serever to hashtable automatically an then
>>> populate JSON object
>>> (still need to call explicitly getLayer, getClass etc., but this is not a
>>> problem):
>>> ...
>>> layers[i].Properties = Tools.PartialSerialize(layer, new Stack(), new
>>> Type[3] { typeof(mapObj), typeof(hashTableObj), typeof(colorObj)});
>>> ...
>>> classes[j].Properties = Tools.PartialSerialize(layerClass, new Stack(),
>>> new
>>> Type[4] { typeof(layerObj), typeof(labelObj), typeof(hashTableObj),
>>> typeof(colorObj)});
>>> ...
>>> styles[k].Properties = Tools.PartialSerialize(classStyle, new Stack(),
>>> new
>>> Type[2]{typeof(hashTableObj), typeof(colorObj)});
>>> ...
>>> mapStub.Properties = Tools.PartialSerialize(map, new Stack(), new
>>> Type[11]
>>> {
>>> typeof(labelObj), typeof(hashTableObj), typeof(fontSetObj),
>>> typeof(labelCacheObj), typeof(outputFormatObj[]), typeof(queryMapObj),
>>> typeof(referenceMapObj), typeof(scalebarObj), typeof(symbolSetObj),
>>> typeof(colorObj), typeof(legendObj)});
>>> ...
>>> JavaScriptSerializer class object allows to perform convertion to client
>>> More often I use script method in my web service that can do it behind
>>> the
>>> scenes.
>>>
>>> How do you do such kind of operation?
>>> --
>>> View this message in context:
>>>
>>> http://www.nabble.com/mapObject-serialization-in-C--(variant)-tp17739919p17739919.html
>>> Sent from the Mapserver - User mailing list archive at Nabble.com.
>>>
>>> _______________________________________________
>>> mapserver-users mailing list
>>> mapserver-users at lists.osgeo.org
>>> http://lists.osgeo.org/mailman/listinfo/mapserver-users
>>>
>> _______________________________________________
>> mapserver-users mailing list
>> mapserver-users at lists.osgeo.org
>> http://lists.osgeo.org/mailman/listinfo/mapserver-users
>>
>> _______________________________________________
>> mapserver-users mailing list
>> mapserver-users at lists.osgeo.org
>> http://lists.osgeo.org/mailman/listinfo/mapserver-users
>>
>>
> _______________________________________________
> mapserver-users mailing list
> mapserver-users at lists.osgeo.org
> http://lists.osgeo.org/mailman/listinfo/mapserver-users
>
More information about the mapserver-dev
mailing list