public WeatherModel(ForecastIO.ForecastIOResponse forecast)
 {
     this.currentWeather = new Current(forecast);
     this.day0 = new Daily(forecast, 0);
     this.day1 = new Daily(forecast, 1);
     this.day2 = new Daily(forecast, 2);
 }

        public override void peerConnected(string peerId, PeerAccessLevel peerAccessLevel, ObjectPrx peerProxy, Current current)
        {
            Trace.TraceError("TerkUserServant.peerConnected()" + current.ToString());
             Trace.TraceError("The peer [" + peerId + "|" + peerAccessLevel + "|" + Util.identityToString(peerProxy.ice_getIdentity()) + "] just connected to me.");

               helper.peerConnected(peerId, peerAccessLevel, peerProxy, current);
        }

 public override VSSoldierPrx instantiateSoldier(Current current__)
 {
     Identity myId = VSNetworkManager.communicator().stringToIdentity(System.Guid.NewGuid().ToString());
     VSSoldierI soldierI = new VSSoldierI();
     VSNetworkManager.Adapter.add(soldierI, myId);
     return VSSoldierPrxHelper.checkedCast(VSNetworkManager.Adapter.createProxy(myId));
 }

 public override void getDateTimeValue(out int year, out short month, out short day, out short hour, out short minute, out short second, Current __current)
 {
     year = this.year;
     month = this.month;
     day = this.day;
     hour = 0;
     minute = 0;
     second = 0;
 }

        // Slice name() operation.

        public override string name(Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }
                return _name;
            }
        }

        public override string[] read(Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                return _lines;
            }
        }

        public override void write(string[] text, Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                _lines = new string[text.Length];
                text.CopyTo((string[])_lines, 0);
            }
        }

 /// <summary>
 /// Method createBoxModule
 /// </summary>
 /// <returns>A Ferda.Modules.BoxModulePrx</returns>
 /// <param name="__current">An Ice.Current</param>
 public override BoxModulePrx createBoxModule(Current __current)
 {
     if (_destroy)
     {
         throw new Ice.ObjectNotExistException();
     }
     Ice.Identity boxModuleIdentity = Ice.Util.stringToIdentity(Ice.Util.generateUUID());
     PropertyBoxModuleI boxModule = new PropertyBoxModuleI(myProxy, this.propertyClassIceId, this.propertyFunctionsIceIds, __current.adapter, boxModuleIdentity, valueFromPrx, defaultValue);
     BoxModulePrx boxModulePrx = boxModule.MyProxy;
     string boxIdentity = Ice.Util.identityToString(boxModulePrx.ice_getIdentity());
     this.boxModules[boxIdentity] = boxModule;
     return boxModulePrx;
 }

 /// <summary>
 /// Method createBoxModuleFactory
 /// </summary>
 /// <returns>A Ferda.Modules.BoxModuleFactoryPrx</returns>
 /// <param name="localePrefs">A  string[]</param>
 /// <param name="manager">A  Ferda.ModulesManager.ManagersEnginePrx</param>
 /// <param name="__current">An Ice.Current</param>
 public override BoxModuleFactoryPrx createBoxModuleFactory(String[] localePrefs, ManagersEnginePrx manager, Current __current)
 {
     PropertyBoxModuleFactoryI boxModuleFactory = new PropertyBoxModuleFactoryI(propertyClassIceId,
                                                                                propertyFunctionsIceIds,
                                                                                myProxy,
                                                                                localePrefs,
                                                                                defaultValue,
                                                                                valueFromPrx,
                                                                                __current.adapter,
                                                                                settingModuleIdentifier);
     this.reaper.Add(boxModuleFactory.MyProxy, boxModuleFactory);
     return boxModuleFactory.MyProxy;
 }

        public override void destroy(Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                c.adapter.remove(id());
                _destroyed = true;
            }

            _parent.removeEntry(_name);
        }

        // Slice createFile() operation.
        public override FilePrx createFile(string name, Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                if(name.Length == 0 || _contents.ContainsKey(name))
                {
                    throw new NameInUse(name);
                }

                var f = new FileI(name, this);
                var node = c.adapter.add(f, f.id());
                _contents.Add(name, f);
                return FilePrxHelper.uncheckedCast(node);
            }
        }

        // Slice createDirectory() operation.
        public override DirectoryPrx createDirectory(string name, Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                if(name.Length == 0 || _contents.ContainsKey(name))
                {
                    throw new NameInUse(name);
                }

                var d = new DirectoryI(name, this);
                var node = c.adapter.add(d, d.id());
                _contents.Add(name, d);
                return DirectoryPrxHelper.uncheckedCast(node);
            }
        }

        // Slice find() operation.

        public override NodeDesc find(string name, Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                NodeI p = (NodeI) _contents[name];
                if(p == null)
                {
                    throw new NoSuchName(name);
                }

                NodeDesc d = new NodeDesc();
                d.name = name;
                d.type = p is FileI ? NodeType.FileType : NodeType.DirType;
                d.proxy = NodePrxHelper.uncheckedCast(c.adapter.createProxy(p.id()));
                return d;
            }
        }

        // Slice list() operation.

        public override NodeDesc[] list(Current c)
        {
            lock(this)
            {
                if(_destroyed)
                {
                    throw new ObjectNotExistException();
                }

                NodeDesc[] ret = new NodeDesc[_contents.Count];
                int i = 0;
                foreach(DictionaryEntry e in _contents)
                {
                    NodeI p = (NodeI)e.Value;
                    ret[i] = new NodeDesc();
                    ret[i].name = (string)e.Key;
                    ret[i].type = p is FileI ? NodeType.FileType : NodeType.DirType;
                    ret[i].proxy = NodePrxHelper.uncheckedCast(c.adapter.createProxy(p.id()));
                    ++i;
                }
                return ret;
            }
        }

 /// <summary>
 /// Method getdateValue
 /// </summary>
 /// <param name="year">A  short</param>
 /// <param name="month">A  short</param>
 /// <param name="day">A  short</param>
 /// <param name="__current">An Ice.Current</param>
 public override void getTimeValue(out short hour, out short minute, out short second, Current __current)
 {
     hour = this.hour;
     minute = this.minute;
     second = this.second;
 }

 public override String getStringValue(Current __current)
 {
     TimeSpan timeSpan = new TimeSpan();
     this.TryGetTimeSpan(out timeSpan);
     return timeSpan.ToString();
 }

 public override DispatchStatus dispatch__(IceInternal.Incoming inS__, Current current)
 {
     byte[] inEncaps = inS__.readParamEncaps();
     AMD_Object_ice_invoke cb = new _AMD_Object_ice_invoke(inS__);
     try
     {
         ice_invoke_async(cb, inEncaps, current);
     }
     catch(System.Exception ex)
     {
         cb.ice_exception(ex);
     }
     return DispatchStatus.DispatchAsync;
 }

 public abstract void ice_invoke_async(AMD_Object_ice_invoke cb, byte[] inEncaps, Current current);

 /// <summary>
 /// Dispatch an incoming request.
 /// </summary>
 /// <param name="inParams">The encoded in-parameters for the operation.</param>
 /// <param name="outParams">The encoded out-paramaters and return value
 /// for the operation. The return value follows any out-parameters.</param>
 /// <param name="current">The Current object to pass to the operation.</param>
 /// <returns>If the operation completed successfully, the return value
 /// is true. If the operation raises a user exception,
 /// the return value is false; in this case, outParams
 /// must contain the encoded user exception. If the operation raises an
 /// Ice run-time exception, it must throw it directly.</returns>
 public abstract bool ice_invoke(byte[] inParams, out byte[] outParams, Current current);

 public static DispatchStatus ice_id___(Ice.Object __obj, IceInternal.Incoming inS__, Current __current)
 {
     inS__.readEmptyParams();
     string __ret = __obj.ice_id(__current);
     IceInternal.BasicStream os__ = inS__.startWriteParams__(FormatType.DefaultFormat);
     os__.writeString(__ret);
     inS__.endWriteParams__(true);
     return DispatchStatus.DispatchOK;
 }